opensmile-2.3.0/ 0000770 0002002 0200001 00000000000 13004722027 012254 5 ustar fe audcore opensmile-2.3.0/RELEASE_NOTES 0000660 0002002 0200001 00000003216 13004722022 014225 0 ustar fe audcore
openSMILE 2.3 (beta)
Major new features:
* Android JNI integration.
While version 2.2. did provide first support for compilation as static binary for Android,
we now offer integration into Apps via the JNI. An example project and a tutorial for
Android Studio are provided which shows how to build a live audio analysis app that
shows audio parameters in real-time in the App UI.
* Configuration file interface updated
Commandline options for audio input and data output formats have been standardised
through modular config files. This allows all major standard
* Batch feature extraction GUI for Windows and batch extraction scripts for Linux *
These make it easier for beginners to extract audio features from a collection of audio files.
* Improved backwards compatibility *
All standard feature sets are verified to be backwards compatible to Version 2.2 and 2.1.
The original feature sets of openEAR are also backwards compatible with
the original openEAR models.
* Updated Version of ComParE 2013-2015 baseline acoustic parameter set *
Several optimisations to the feature extraction code were applied and
an updated version of ComParE was released. It has the same features as
the previous version, but is now numerically optimised. It is referred to
as ComParE_2016, as it is released in 2016.
It is not the Interspeech ComParE 2016 baseline feature set (this is still the 2013 one)!!
* Lots of various fixes and improvements *
We've added many minor points, fixed bugs, and improved performance.
E.g. we have improved the support for modulation spectra as functionals and optimized
Jitter computation through a better pitch period detection algorithm.
opensmile-2.3.0/buildWithInstalledPortAudio.sh 0000770 0002002 0200001 00000003716 13004722025 020242 0 ustar fe audcore #!/bin/sh
# This file is part of openSMILE.
#
# Copyright (c) audEERING. All rights reserved.
# See the file COPYING for details on license terms.
#Usage buildPA.sh [install-prefix]
# Default install prefix is $Pwd/inst
# EXPERIMENTAL AND UNSUPPORTED!!!! Update to latest build code in buildWithPortaudio.sh to make it work!
Pwd=`pwd`;
if [ "$1" != "" ]; then
INSTPREFIX=$1;
else
INSTPREFIX="$Pwd/inst";
fi
echo "++++++++++++++ Compiling openSMILE...."
./autogen.sh ;
./autogen.sh ;
if [ $? != 0 ]; then
echo "autogen.sh failed!";
exit -1;
fi
mkdir inst
export CXXFLAGS="-O2 -mfpmath=sse -march=native"
export CFLAGS="-O2 -mfpmath=sse -march=native"
#export CXXFLAGS="-O2 -mfpmath=sse -mtune=athlon64"
#export CFLAGS="-O2 -mfpmath=sse -mtune=athlon64"
#./configure --prefix=$Pwd/inst --enable-static --disable-shared &&
./configure --prefix=$INSTPREFIX --with-portaudio="yes"
if [ $? != 0 ]; then
echo "failed to configure openSMILE!";
exit -1;
fi
make clean &&
make -j8 ; make install
if [ $? != 0 ]; then
echo "failed to build or install openSMILE!";
exit -1;
fi
mv $INSTPREFIX/bin/SMILExtract $INSTPREFIX/bin/SMILExtract.bin
echo "#!/bin/sh" > $INSTPREFIX/bin/SMILExtract
echo "export LD_LIBRARY_PATH=\"`dirname \$0`/../lib\" ; \$0.bin \$* " >> $INSTPREFIX/bin/SMILExtract
chmod +x $INSTPREFIX/bin/SMILExtract
$INSTPREFIX/bin/SMILExtract -H cPortaudio 2> tmp
TMP=`cat tmp | grep cPortaudio `;
rm tmp
if [ "$TMP" = "" ]; then
echo "ERROR: PortAudio was not found on your system, please check if you have the development headers installed! If unsure, use the script buildWithPortAudio.sh! openSMILE was built, however without portaudio support!";
else
echo ""
echo "build successfull."
echo " You can now use the $Pwd/inst/bin/SMILExtract executable,"
echo " and add $Pwd/inst/bin to your path."
echo ""
echo " Please note that $Pwd/inst/bin/SMILExtract is a wrapper script"
echo " which sets up the library path and calls SMILExtract.bin"
echo ""
fi
opensmile-2.3.0/scripts/ 0000770 0002002 0200001 00000000000 13004722023 013737 5 ustar fe audcore opensmile-2.3.0/scripts/gnuplot/ 0000770 0002002 0200001 00000000000 13004722023 015427 5 ustar fe audcore opensmile-2.3.0/scripts/gnuplot/plotmatrix.sh 0000770 0002002 0200001 00000000477 13004722023 020201 0 ustar fe audcore #!/bin/sh
if [ "$1" = "" ]; then
echo "Usage: plotmatrix.sh ";
exit;
fi
perl transpose.pl $1 .tmp.plot.dat
echo "Starting gnuplot, type 'quit' to exit the gnuplot prompt!"
gnuplot -persist plotmatrix.gp
## to run gnuplot an remain in interactive mode:
## gnuplot plotmatrix.gp -
rm .tmp.plot.dat
opensmile-2.3.0/scripts/gnuplot/plotaudspec.sh 0000770 0002002 0200001 00000000375 13004722023 020316 0 ustar fe audcore #!/bin/sh
if [ "$1" = "" ]; then
echo "Usage: plotaudspec.sh ";
exit;
fi
perl transpose_lin.pl $1 .tmp.plot.dat
echo "Starting gnuplot, type 'quit' to exit the gnuplot prompt!"
gnuplot -persist plotmatrix_spec.gp
rm .tmp.plot.dat
opensmile-2.3.0/scripts/gnuplot/plotmatrix.gp 0000660 0002002 0200001 00000000337 13004722023 020166 0 ustar fe audcore
set pm3d map
set palette gray
set view map
set xlabel 'Time/frames'
set ylabel 'Feature Index'
set zlabel 'Power'
## change the name '.tmp.plot.dat' to your filename...
splot '.tmp.plot.dat' matrix title 'Matrix plot'
opensmile-2.3.0/scripts/gnuplot/gpframeconvert.pl 0000770 0002002 0200001 00000001574 13004722023 021020 0 ustar fe audcore #!/usr/bin/perl
# Usage: gpconvert.pl [output file , default: same as input]
#
# this script converts a CSV file (; delimiter)
# and saves it as a space separated file for gnuplot
#
$col = $ARGV[0];
unless ($ARGV[1]) {
print "Usage: gpframeconvert.pl [output file, default: overwrite input file]\n";
exit -1;
}
$j=0;
open(F,"<$ARGV[1]");
while() {
$_=~s/\r?\n//;
if ($_ !~ /;/) { print "no column delimiter ; found !"; exit -1; }
if ($_ !~ /[a-df-zA-DF-Z]/) { # skip a header line with alphanumeric characters
split(/;/); # <<- the delimiter ;
for ($i=0;$i<=$#_;$i++) { $d[$i][$j] = $_[$i]; }
$j++;
}
}
close(F);
if ($ARGV[2]) {
open(F,">$ARGV[2]");
} else {
open(F,">$ARGV[1]");
}
for ($n=0; $n<$#d; $n++) {
$s="$n ";
# for ($i=0; $i<$#d; $i++) {
$s.=$d[$n][$col]." ";
# }
chop($s);
print F $s."\n";
}
close(F);
opensmile-2.3.0/scripts/gnuplot/transpose_lin.pl 0000770 0002002 0200001 00000002016 13004722023 020646 0 ustar fe audcore #!/usr/bin/perl
# Usage: transpose.pl [output file , default: same as input]
#
# this script transposes a CSV file (; delimiter)
# and saves it as a space separated file for gnuplot
# the values in the CSV file are squared, which usually
# leads to a better display behaviour for spectrograms, etc.
# Please see the comments in the code below, how to change this.
#
unless ($ARGV[0]) {
print "Usage: transpose.pl [output file, default: overwrite input file]\n";
exit -1;
}
$j=0;
open(F,"<$ARGV[0]");
while() {
$_=~s/\r?\n//;
if ($_ !~ /;/) { print "no column delimiter ; found !"; exit -1; }
if ($_ !~ /[a-df-zA-DF-Z]/) { # skip a header line with alphanumeric characters
split(/;/); # <<- the delimiter ;
for ($i=0;$i<=$#_;$i++) { $d[$i][$j] = $_[$i]; }
$j++;
}
}
close(F);
if ($ARGV[1]) {
open(F,">$ARGV[1]");
} else {
open(F,">$ARGV[0]");
}
for ($n=$#d; $n>=0; $n--) {
$s="";
for ($i=0; $i<$j; $i++) {
$s.=$d[$n][$i]." ";
}
chop($s);
print F $s."\n";
}
close(F);
opensmile-2.3.0/scripts/gnuplot/plotmatrix_chroma.gp 0000660 0002002 0200001 00000000330 13004722023 021510 0 ustar fe audcore
set pm3d map
set palette gray
set view map
set xlabel 'Time/frames'
set ylabel 'Semitone bin (0-11)'
set zlabel 'Intensity'
## change the name to your filename...
splot '.tmp.plot.dat' matrix title 'Chromagram'
opensmile-2.3.0/scripts/gnuplot/plotcontour.gp 0000660 0002002 0200001 00000000204 13004722023 020344 0 ustar fe audcore
set title 'Feature contour plot'
set ylabel 'Amplitude/Value'
set xlabel 'Time/frames'
plot '.tmp.plot.dat' using 1:2 with lines
opensmile-2.3.0/scripts/gnuplot/plotchroma.sh 0000770 0002002 0200001 00000000372 13004722023 020140 0 ustar fe audcore #!/bin/sh
if [ "$1" = "" ]; then
echo "Usage: plotchroma.sh ";
exit;
fi
perl transpose.pl $1 .tmp.plot.dat
echo "Starting gnuplot, type 'quit' to exit the gnuplot prompt!"
gnuplot -persist plotmatrix_chroma.gp
rm .tmp.plot.dat
opensmile-2.3.0/scripts/gnuplot/transpose.pl 0000770 0002002 0200001 00000002257 13004722023 020013 0 ustar fe audcore #!/usr/bin/perl
# Usage: transpose.pl [output file , default: same as input]
#
# this script transposes a CSV file (; delimiter)
# and saves it as a space separated file for gnuplot
# the values in the CSV file are squared, which usually
# leads to a better display behaviour for spectrograms, etc.
# Please see the comments in the code below, how to change this.
#
unless ($ARGV[0]) {
print "Usage: transpose.pl [output file, default: overwrite input file]\n";
exit -1;
}
$j=0;
open(F,"<$ARGV[0]");
while() {
$_=~s/\r?\n//;
if ($_ !~ /;/) { print "no column delimiter ; found !"; exit -1; }
if ($_ !~ /[a-df-zA-DF-Z]/) { # skip a header line with alphanumeric characters
split(/;/); # <<- the delimiter ;
for ($i=0;$i<=$#_;$i++) { $d[$i][$j] = $_[$i]; }
$j++;
}
}
close(F);
if ($ARGV[1]) {
open(F,">$ARGV[1]");
} else {
open(F,">$ARGV[0]");
}
for ($n=$#d; $n>=0; $n--) {
$s="";
for ($i=0; $i<$j; $i++) {
$s.=$d[$n][$i]*$d[$n][$i]." "; ## comment out this line with a "##" when using the line below
## $s.=$d[$n][$i]." "; ## uncomment this line, to use the magnitude instead of power
}
chop($s);
print F $s."\n";
}
close(F);
opensmile-2.3.0/scripts/gnuplot/gpconvert.pl 0000770 0002002 0200001 00000001567 13004722023 020007 0 ustar fe audcore #!/usr/bin/perl
# Usage: gpconvert.pl [output file , default: same as input]
#
# this script converts a CSV file (; delimiter)
# and saves it as a space separated file for gnuplot
#
$col = $ARGV[0];
unless ($ARGV[1]) {
print "Usage: gpconvert.pl [output file, default: overwrite input file]\n";
exit -1;
}
$j=0;
open(F,"<$ARGV[1]");
while() {
$_=~s/\r?\n//;
if ($_ !~ /;/) { print "no column delimiter ; found !"; exit -1; }
if ($_ !~ /[a-df-zA-DF-Z]/) { # skip a header line with alphanumeric characters
split(/;/); # <<- the delimiter ;
for ($i=0;$i<=$#_;$i++) { $d[$i][$j] = $_[$i]; }
$j++;
}
}
close(F);
if ($ARGV[2]) {
open(F,">$ARGV[2]");
} else {
open(F,">$ARGV[1]");
}
for ($n=0; $n<$j; $n++) {
$s="$n ";
# for ($i=0; $i<$#d; $i++) {
$s.=$d[$col][$n]." ";
# }
chop($s);
print F $s."\n";
}
close(F);
opensmile-2.3.0/scripts/gnuplot/plotframe.sh 0000770 0002002 0200001 00000000706 13004722023 017762 0 ustar fe audcore #!/bin/sh
if [ "$1" = "" ]; then
echo "Usage: plotframe.sh [index of frame to extract, default: the first (0)]";
exit;
fi
if [ "$2" = "" ]; then
perl gpframeconvert.pl 0 $1 .tmp.plot.dat
else
perl gpframeconvert.pl $2 $1 .tmp.plot.dat
fi
echo "Starting gnuplot, type 'quit' to exit the gnuplot prompt!"
gnuplot -persist plotframe.gp
## to run gnuplot an remain in interactive mode:
## gnuplot plotframe.gp -
rm .tmp.plot.dat
opensmile-2.3.0/scripts/gnuplot/plotmatrix_spec.gp 0000660 0002002 0200001 00000000341 13004722023 021173 0 ustar fe audcore
set pm3d map
set palette gray
set view map
set xlabel 'Time/frames'
set ylabel 'Spectral bin/band'
set zlabel 'Magnitude/Intensity'
## change the name to your filename...
splot '.tmp.plot.dat' matrix title 'Spectrogram'
opensmile-2.3.0/scripts/gnuplot/plotframe.gp 0000660 0002002 0200001 00000000210 13004722023 017742 0 ustar fe audcore
set title 'Plot of a single frame'
set ylabel 'Amplitude/Value'
set xlabel 'Feature index'
plot '.tmp.plot.dat' using 1:2 with lines
opensmile-2.3.0/scripts/gnuplot/plotcontour.sh 0000770 0002002 0200001 00000000531 13004722023 020355 0 ustar fe audcore #!/bin/sh
if [ "$1" = "" ]; then
echo "Usage: plotcontour.sh ";
exit;
fi
perl gpconvert.pl $1 $2 .tmp.plot.dat
echo "Starting gnuplot, type 'quit' to exit the gnuplot prompt!"
gnuplot -persist plotcontour.gp
## to run gnuplot an remain in interactive mode:
## gnuplot plotcontour.gp -
rm .tmp.plot.dat
opensmile-2.3.0/scripts/vad/ 0000770 0002002 0200001 00000000000 13004722023 014511 5 ustar fe audcore opensmile-2.3.0/scripts/vad/vad_segmenter.conf 0000770 0002002 0200001 00000003530 13004722023 020207 0 ustar fe audcore ///////////////////////////////////////////////////////////////////////////////////////
///////// > openSMILE LSTM-RNN voice activity detector< //////////////////
///////// //////////////////
///////// (c) audEERING UG (haftungsbeschränkt), //////////////////
///////// All rights reserverd. //////////////////
///////////////////////////////////////////////////////////////////////////////////////
[componentInstances:cComponentManager]
instance[dataMemory].type = cDataMemory
instance[waveSource].type = cWaveSource
[waveSource:cWaveSource]
writer.dmLevel = wave
filename = \cm[inputfile(I){input.wav}:name of input file]
monoMixdown = 1
start = 0
end = -1
endrel = 0
noHeader = 0
buffersize_sec = 10
; inculdes a VAD module
\{vad_opensource.conf.inc}
; and a turn detector module
\{\cm[turnDetector(T){turnDetector.conf.inc}:filename of turn detector config file]}
[componentInstances:cComponentManager]
; the wave file segmenter
instance[waveSinkCut].type = cWaveSinkCut
; optional: CSV output
instance[csvSink].type = cCsvSink
printLevelStats = 0
[waveSinkCut:cWaveSinkCut]
reader.dmLevel = framesVAD
fileBase = \cm[waveoutput(W){output_segment_}:prefix of WAV output files]
fileExtension = .wav
fileNameFormatString = %s%04d%s
startIndex = 1
preSil = 0.1
postSil = 0.1
multiOut = 1
sampleFormat = 16bit
; sample rate should be read from the input level
; automatically. In some cases this does not work due to
; round-off errors, so you can force it manually here:
;forceSampleRate = 44100
;forceSampleRate = 16000
saveSegmentTimes = \cm[saveSegmentTimes{?}:file to save segment times to]
[csvSink:cCsvSink]
reader.dmLevel=vad_VAD_voice
filename= \cm[csvoutput{?}:name of VAD output file]
printHeader = 0
timestamp = 1
number = 0
opensmile-2.3.0/scripts/vad/turnDetector.conf.inc 0000770 0002002 0200001 00000002212 13004722023 020612 0 ustar fe audcore ///////////////////////////////////////////////////////////////////////////////////////
///////// > openSMILE LSTM-RNN voice activity detector< //////////////////
///////// //////////////////
///////// (c) audEERING UG (haftungsbeschränkt), //////////////////
///////// All rights reserverd. //////////////////
///////////////////////////////////////////////////////////////////////////////////////
;; turn detector configuration module
[componentInstances:cComponentManager]
instance[turn].type=cTurnDetector
[turn:cTurnDetector]
reader.dmLevel=vad_VAD_voice
writer.dmLevel=isTurn
readVad=1
threshold = -0.1
threshold2 = -0.1
writer.levelconf.noHang=1
msgInterval = 0
messageRecp = waveSinkCut
eventRecp = waveSinkCut
statusRecp = waveSinkCut
debug=\cm[turndebug{4}:set this to 1 to see turn/speaking debug messages]
;; examples for constraining the turn length
;; minTurnLengthTurnFrameTimeMessage=0.9
;; maxTurnLength=10.0
; default (0) is infinite maximum length
maxTurnLength=0
maxTurnLengthGrace=1
nPre = 8
nPost = 35
opensmile-2.3.0/scripts/vad/vad_opensource.conf 0000660 0002002 0200001 00000002331 13004722023 020374 0 ustar fe audcore ///////////////////////////////////////////////////////////////////////////////////////
///////// > openSMILE LSTM-RNN voice activity detector< //////////////////
///////// //////////////////
///////// (c) audEERING UG (haftungsbeschränkt), //////////////////
///////// All rights reserverd. //////////////////
///////////////////////////////////////////////////////////////////////////////////////
[componentInstances:cComponentManager]
instance[dataMemory].type = cDataMemory
instance[waveSource].type = cWaveSource
; verbose level stats
; printLevelStats = 6
[waveSource:cWaveSource]
writer.dmLevel = wave
filename = \cm[inputfile(I){input.wav}:name of input file]
monoMixdown = 1
start = 0
end = -1
endrel = 0
noHeader = 0
buffersize_sec = 10
;; includes the VAD module
\{vad_opensource.conf.inc}
[componentInstances:cComponentManager]
; output vad activations
instance[csvSink].type = cCsvSink
[csvSink:cCsvSink]
reader.dmLevel=vad_VAD_voice
filename= \cm[csvoutput(O){vad.csv}:name of VAD output file]
printHeader = 0
timestamp = 1
number = 0
delimChar = ,
opensmile-2.3.0/scripts/vad/README.txt 0000770 0002002 0200001 00000004441 13004722023 016215 0 ustar fe audcore ///////////////////////////////////////////////////////////////////////////////////////
///////// > openSMILE LSTM-RNN voice activity detector< //////////////////
///////// //////////////////
///////// (c) audEERING UG (haftungsbeschränkt), //////////////////
///////// All rights reserverd. //////////////////
///////////////////////////////////////////////////////////////////////////////////////
This folder contains configuration files and models for a
prototype LSTM-RNN Voice Activity Detector.
This is meant as an example to show how to implement such
a VAD in openSMILE with the RNN components and to provide
a simple VAD for prototype development. The noise-robustness
of this VAD is *not* state-of-the-art, it has been built on
a small-scale research data-set, mainly for clean speech.
This config implements a voice activity detector as described in:
Eyben, F.; Weninger, F.; Squartini, S.; Schuller, B.:
"Real-life voice activity detection with LSTM Recurrent Neural
Networks and an application to Hollywood movies,"
Proc. of ICASSP 2013, pp. 483-487, 26-31 May 2013.
doi: 10.1109/ICASSP.2013.6637694
The models are not the same models as used in the paper, but a
preliminary version of the data presented in the paper.
If you need a more accurate and noise-robust VAD,
contact audEERING at info@audeering.com for a demo of
our latest commercial VAD technology.
We have extremely robust detectors, which are even capable
of reliably detecting sung speech (vocals) in single channel
polyphonic music recordings.
There are two main config files to start from here:
vad_opensource.conf : Dumps vad activations per frame to CSV
vad_segmenter.conf : Creates wave files with voice segments
and optionally writes activations to CSV
Run
SMILExtract -ccmdHelp -C
to see the commandline options supported by these config files.
If you want to include the VAD as a module in your own
configuration files, you can use:
vad_opensource.conf.inc
turnDetector.conf.inc
See the comments in these config files for level input/output
naming requirements. See the main config files for examples
of how to use the module includes.
opensmile-2.3.0/scripts/vad/rplp18d_norm.dat 0000660 0002002 0200001 00000001100 13004722023 017521 0 ustar fe audcore -* Z_wvc)a%)lo$pkRZW M'm߿D {SֿkFͦӿ;1مɿi4CÿM}#ܱw[tk?lV
ѭ?! >ral>>kv>) >%a> Yk/>& YT?U o>D, >Q s>jǂ&o`>w\[|>~ ެ4>H@B'Ʊydkw>x
snw?HZnJ?&^*Ӹ?
qB? O7?0R??C86?n& ?oz
?_Ԟ?xT?}z?Tza?3`H?+0&?4"?jI^-? ַ?X+ȶ?_*g?T
ظ?&6I? hwŝ?j &k?A!H?_Ё6ܹ?A
/6?e
Y?ԏ%˵?E2?mt#? ]?Xx ;? openSMILE LSTM-RNN voice activity detector< //////////////////
///////// //////////////////
///////// (c) audEERING UG (haftungsbeschränkt), //////////////////
///////// All rights reserverd. //////////////////
///////////////////////////////////////////////////////////////////////////////////////
[componentInstances:cComponentManager]
instance[framerVAD].type = cFramer
instance[vectorPreemphasisVAD].type = cVectorPreemphasis
instance[windowerVAD].type = cWindower
; magnitude FFT spectrum
instance[fftVAD].type=cTransformFFT
instance[fftmagVAD].type=cFFTmagphase
; compute critical-bands from power spectrum
instance[melspecVAD].type=cMelspec
; compute PLP 1-12 from critical-band spectrum
instance[plpVAD].type=cPlp
; compute log-energy from raw signal frames
; (not windowed, not pre-emphasised: that's the way HTK does it)
;instance[energyVAD].type=cEnergy
; compute delta coefficients from PLP and energy
instance[deltaVAD].type=cDeltaRegression
; compute acceleration coefficients from delta coefficients of PLP and energy
;instance[accelVAD].type=cDeltaRegression
; MVN (2x)
instance[mvnVAD].type = cVectorMVN
;; experimental MVN adaption, uncomment to enable
;; and also change reader.dmLevel of lstm_vad component
;instance[mn2VAD].type = cVectorMVN
; LSTM for VAD
instance[lstmVAD].type=cRnnProcessor
instance[dataSelectorVAD].type = cDataSelector
[framerVAD:cFramer]
reader.dmLevel = wave
writer.dmLevel = framesVAD
// nameAppend =
copyInputName = 1
frameMode = fixed
// frameListFile =
// frameList =
frameSize = 0.025000
frameStep = 0.01
frameCenterSpecial = left
buffersize = 100000
noPostEOIprocessing = 1
[vectorPreemphasisVAD:cVectorPreemphasis]
reader.dmLevel = framesVAD
writer.dmLevel = prframesVAD
// nameAppend =
copyInputName = 1
processArrayFields = 1
k = 0.970000
de = 0
[windowerVAD:cWindower]
reader.dmLevel = prframesVAD
writer.dmLevel = winframesVAD
// nameAppend =
copyInputName = 1
processArrayFields = 1
gain = 1
offset = 0
winFunc = ham
;sigma = 0.400000
;alpha = 0.160000
[fftVAD:cTransformFFT]
reader.dmLevel=winframesVAD
writer.dmLevel=fftVAD
[fftmagVAD:cFFTmagphase]
reader.dmLevel=fftVAD
writer.dmLevel=fftmagVAD
[melspecVAD:cMelspec]
reader.dmLevel=fftmagVAD
writer.dmLevel=melspec_powerVAD
; no htk compatible sample value scaling
htkcompatible = 0
nBands = 26
; use power spectrum instead of magnitude spectrum
usePower = 1
lofreq = 0
hifreq = 8000
specScale = mel
[plpVAD:cPlp]
reader.dmLevel=melspec_powerVAD
writer.dmLevel=plp_VAD
buffersize=100
firstCC = 1
lpOrder = 18
cepLifter = 22
compression = 0.33
htkcompatible = 0
newRASTA = 1
RASTA = 0
rastaUpperCutoff = 29.0
rastaLowerCutoff = 0.9
doIDFT = 1
doLpToCeps = 1
doLP = 1
doInvLog = 1
doAud = 1
doLog = 1
[energyVAD:cEnergy]
reader.dmLevel=winframesVAD
writer.dmLevel=energy_VAD
htkcompatible=1
rms = 0
log = 1
[deltaVAD:cDeltaRegression]
reader.dmLevel=plp_VAD
writer.dmLevel=plpde_VAD
deltawin=2
blocksize=1
[accelVAD:cDeltaRegression]
reader.dmLevel=plpde_VAD
writer.dmLevel=plpdede_VAD
deltawin=2
blocksize=1
[mvnVAD:cVectorMVN]
reader.dmLevel = plp_VAD;plpde_VAD
writer.dmLevel = plpmvn_VAD
// nameAppend =
copyInputName = 1
processArrayFields = 0
mode = transform
initFile = rplp18d_norm.dat
htkcompatible = 0
meanEnable = 1
stdEnable = 1
normEnable = 0
; experimental incremental MVN adaptation
; disabled by default
[mn2VAD:cVectorMVN]
reader.dmLevel = plpmvn_VAD
writer.dmLevel = plpmvn2_VAD
processArrayFields = 0
mode = incremental
updateMethod = fix
fixedBuffer = 30.0
meanEnable = 1
stdEnable = 0
normEnable = 0
[lstmVAD:cRnnProcessor]
reader.dmLevel = plpmvn_VAD
;; enable this, if you enable the
;; experimental incremental adaptaion
; reader.dmLevel = plpmvn2_VAD
writer.dmLevel = vad_VAD
netfile = lstmvad_rplp18d_12.net
[dataSelectorVAD:cDataSelector]
reader.dmLevel = vad_VAD
writer.dmLevel = vad_VAD_voice
nameAppend = vadBin
copyInputName = 1
selectedRange = 0
elementMode = 1
opensmile-2.3.0/scripts/arff_naninfzero_checker.pl 0000660 0002002 0200001 00000002265 13004722023 021135 0 ustar fe audcore #!/usr/bin/perl
# This file is part of openSMILE.
#
# Copyright (c) audEERING. All rights reserved.
# See the file COPYING for details on license terms.
# locate nan in arff files (and inf) and display affected attribute
$arff=$ARGV[0];
unless ($arff) {
print " -- locate nan in arff files (and inf) and display affected attribute --\n";
print " -- this is useful for debugging new feature extractor components --\n";
print "USAGE: $0 \n";
exit;
}
open(FILE,"<$arff");
$data=0; my @attr;
@nonzero; $N=0;
while() {
my $line=$_;
$line=~ s/\n$//; $line=~s/\r$//;
if ($data) {
@el = split(/,/,$line);
$N=$#el+1;
for ($i=0; $i<=$#el; $i++) {
if ($el[$i] != 0.0) {
$nonzero[$i] = 1;
}
#if ($el[$i] !~ /^0\.000000e\+00/) {
# $nonzero[$i] = 1;
#}
if (($el[$i] =~ /nan/i)||($el[$i] =~ /inf/i)) {
print "nan/inf @ # $i = $attr[$i]\n";
}
}
} else {
if($line=~/^\@data/) { $data = 1; }
else {
if($line=~/^\@attribute ([^ ]+) /) {
push(@attr,$1);
}
}
}
}
close(FILE);
for ($i=0; $i<$N; $i++) {
unless ($nonzero[$i]) {
print "all-zero: ".$attr[$i]."\n";
}
}
opensmile-2.3.0/scripts/modeltrain/ 0000770 0002002 0200001 00000000000 13004722023 016075 5 ustar fe audcore opensmile-2.3.0/scripts/modeltrain/makemodel.pl 0000660 0002002 0200001 00000015446 13004722023 020403 0 ustar fe audcore #!/usr/bin/perl
$do_standardise = 0; # TODO: implement speaker standardisation...
$do_select = 0;
$regression = 0; # 0: classification model , 1: regression model
#--------------
use File::Basename;
require "arff-functions.pl";
#print "Operating system: $^O\n\n";
if ($#ARGV < 0) {
print "\nUsage: perl makemodel.pl [SMILExtract config for corpus mode] [SVM Config]\n\n";
exit -1;
}
# check if we run on windows...
if ($^O =~ /win/i) {
$ext = ".exe";
unless (-f "libsvm-small/svm-train$ext") {
print "ERROR: The libsvm binaries in scripts/modeltrain/libsvm-small \n";
print " cannot be found (svm-train.exe, svm-scale.exe, ...)\n";
print " Please compile them first, or get a new openEAR realease\n";
print " which contains the binaries (or contact the authors!)\n";
exit;
}
} else {
$ext = "";
# check for libsvm binaries...
unless (-f "libsvm-small/svm-train") {
# assume binaries have not yet been compiled
print "WARNING: you have not yet compiled the LibSVM binaries!\n";
print " I will try to compile, this should work, if you have \n";
print " called this script from the 'scripts/modeltrain'\n";
print " directory. \n";
print " If you get errors in the following output, please do \n";
print " the following manually (relative to openEAR root path): \n";
print " cd scripts/modeltrain/libsvm-small \n";
print " make \n";
$ret = system("cd libsvm-small ; make");
if ($ret == 0) {
print "LibSVM built successfully!\n";
} else {
print "FAILED building LibSVM!!\n";
exit -1;
}
}
}
$xtract = "../../SMILExtract$ext";
mkdir ("built_models");
mkdir ("work");
$corp = $ARGV[0]; # full path to corpus OR direct arff file...
if ($corp =~ /\.arff$/i) {
$mode="arff";
unless (-f "$corp") {
print "ERROR '$corp' is not an ARFF file or does not exist!\n";
exit;
}
$cname=basename($corp);
$cname =~s/\.arff$//i;
$arff = $corp;
$modelpath = "built_models/$cname";
$workpath = "work/$cname";
$svmConfig = $ARGV[1];
} else {
$mode = "corp";
unless (-d "$corp") {
print "ERROR '$corp' is not a corpus directory or does not exist!\n";
exit;
}
if ($corp =~ /\/([^\/]+)_FloEmoStdCls/) {
$cname = $1;
} else {
$cname = basename($corp);
}
$conf = $ARGV[1];
$svmConfig = $ARGV[2];
unless ($conf) { $conf = "is09s.conf"; }
$cb=$conf; $cb=~s/\.conf$//;
$modelpath = "built_models/$cname";
$workpath = "work/$cname";
$arff = "$workpath/$cb.arff";
}
mkdir("$modelpath");
mkdir("$workpath");
#extract features
if ($mode eq "corp") {
print "-- Corpus mode --\n Running feature extraction on corpus '$corp' ...\n";
system("perl stddirectory_smileextract.pl \"$corp\" \"$conf\" \"$arff\"");
} else {
print "-- Arff mode --\n Copying '$arff' to work directory ...\n";
$arffb = basename($arff);
# print("cp $arff $workpath/$arffb");
system("cp $arff $workpath/$arffb");
$arff = "$workpath/$arffb";
}
# ? standardise features
if ($do_standardise) {
print "NOTE: standardsise not implemented yet, svm-scale will do the job during building of model\n";
}
# ? select features
$lsvm=$arff; $lsvm=~s/\.arff$/.lsvm/i;
if ($do_select) {
print "Selecting features (CFS)... (this requires weka)\n";
$fself = $arff;
$fself=~s/\.arff/.fselection/i;
system("perl fsel.pl $arff");
$arff = "$arff.fsel.arff";
# TOOD: remove index fields, convert to LSVM, re-use code from below..
system("perl arffToLsvm.pl $arff $lsvm");
} else {
$fself="";
print "Converting arff to libsvm feature file (lsvm) ...\n";
# convert to lsvm
my $hr = &load_arff($arff);
my $numattr = $#{$hr->{"attributes"}};
if ($hr->{"attributes"}[0]{"name"} =~ /^name$/) {
$hr->{"attributes"}[0]{"selected"} = 0; # remove filename
}
if ($hr->{"attributes"}[0]{"name"} =~ /^filename$/) {
$hr->{"attributes"}[0]{"selected"} = 0; # remove filename
}
if ($hr->{"attributes"}[1]{"name"} =~ /^timestamp$/) {
$hr->{"attributes"}[1]{"selected"} = 0; # remove filename
}
if ($hr->{"attributes"}[1]{"name"} =~ /^frameIndex$/) {
$hr->{"attributes"}[1]{"selected"} = 0; # remove filename
if ($hr->{"attributes"}[2]{"name"} =~ /^frameTime$/) {
$hr->{"attributes"}[2]{"selected"} = 0; # remove filename
}
}
if ($hr->{"attributes"}[1]{"name"} =~ /^frameTime$/) {
$hr->{"attributes"}[1]{"selected"} = 0; # remove filename
}
#$hr->{"attributes"}[$numattr-1]{"selected"} = 0; # remove continuous label
&save_arff_AttrSelected($arff,$hr);
system("perl arffToLsvm.pl $arff $lsvm");
# generate fsel file with list of features:
$outpArff=$arff;
$feaTUMfselfile=basename($arff);
$feaTUMfselfile=~ s/\.arff/.fselection/;
$feaTUMfselfile="work/$feaTUMfselfile";
# count number of features first
$nStr = 0; $haveNom = 0;
open(FILE,"<$outpArff");
while () {
my $line = $_; chop($line);
if ($line =~ /^\@attribute (.+?) numeric/) {
$nStr++;
}
if ($line =~ /^\@attribute (.+?) \{?.+,.+\}?/) {
$haveNom=1;
}
if ($line =~ /^\@data/) { last; }
}
close(FILE);
if ($haveNom==0) { $nStr--; }
else { print "haveNom\n"; }
#default : skip the last numeric attribute, if no nominal attribute is present
$nNumCur=0;
open(OUT,">$feaTUMfselfile");
print OUT "str\n";
print OUT "$nStr\n";
open(FILE,"<$outpArff");
while () {
my $line = $_; chop($line);
if ($line =~ /^\@attribute (.+?) numeric/) {
$attr = $1;
$nNumCur++;
# print "selecting: $attr \n";
if ($haveNom==1) {
print OUT "$attr\n";
} elsif (($nNumCur <= $nStr)) {
print OUT "$attr\n";
}
}
if ($line =~ /^\@data/) { last; }
}
close(FILE);
close(OUT);
$fself = $feaTUMfselfile;
}
# train model
print "Training libsvm model ...\n";
system("perl buildmodel.pl $lsvm $svmConfig");
$discfile = $lsvm; $discfile=~s/\.lsvm$/.disc/;
open(FILE,"<$discfile");
$disc=; $disc=~s/\r?\n$//;
close(FILE);
$conf = $lsvm;
$conf =~ s/\.lsvm$/.config/;
# copy final files to modelpath
$scale = $lsvm; $scale=~s/\.lsvm$/.scale/;
$model = $lsvm; $model=~s/\.lsvm$/.model/;
$cls = $lsvm; $cls=~s/\.lsvm$/.classes/;
if ($cb) { $cb = "$cb."; }
if ($do_select) { $sel="cfssel."; }
else { $sel="allft."; }
system("cp $scale $modelpath/$cb$sel"."scale");
system("cp $model $modelpath/$cb$sel"."model");
# convert to binary model
unless (-f "../../svm/modelconverter$ext") {
print "WARNING: modelconverter not found in ../../svm ! If you are running this script on windows, you must compile the modelconverter.cpp file manually!\n";
system("cd ../../svm ; sh compileConverter.sh");
}
system("../../svm/modelconverter $modelpath/$cb$sel"."model $modelpath/$cb$sel"."model.bin");
system("cp $conf $modelpath/$cb$sel"."config");
if ($disc) {
system("cp $cls $modelpath/$cb$sel"."classes");
}
if ($fself) {
system("cp $fself $modelpath/$cb$sel"."fselection");
}
opensmile-2.3.0/scripts/modeltrain/fsel.pl 0000770 0002002 0200001 00000003657 13004722023 017401 0 ustar fe audcore #!/usr/bin/perl
# load train.arff in weka and so CFS
# convert resulting arff to openEAR feature selection file
$input_arff = $ARGV[0];
##### CHANGE THIS TO YOUR WEKA PATH
$wekapath = "\$CLASSPATH:/home/don/eyb/inst/weka-3-5-6/weka.jar";
$wekacmd = "java -Xmx2048m -classpath $wekapath ";
##############################################################
# run weka...
sub run_weka {
my $cmdline = $_[0];
my $retval = system($wekacmd." ".$cmdline);
if ($retval) {
print "ERROR running Weka\n";
exit 1;
}
return $retval;
}
require "arff-functions.pl";
print "removing filename and timestamp fields from $input_arff ...\n";
$stripped_arff = $input_arff.".stripped.arff";
$fsel_tmp_arff = $input_arff.".fsel.arff";
my $hr = &load_arff($input_arff);
my $numattr = $#{$hr->{"attributes"}};
$hr->{"attributes"}[0]{"selected"} = 0; # filename
$hr->{"attributes"}[1]{"selected"} = 0; # timestamp
&save_arff_AttrSelected($stripped_arff,$hr);
print "Running WEKA CFS feature selection ...\n";
&run_weka("weka.filters.supervised.attribute.AttributeSelection -E \"weka.attributeSelection.CfsSubsetEval\" -S \"weka.attributeSelection.BestFirst -D 1 -N 5\" -i \"$stripped_arff\" -o \"$fsel_tmp_arff\" ");
system("./arffToLsvm.pl $fsel_tmp_arff");
# convert arff:
$outpArff=$fsel_tmp_arff;
$feaTUMfselfile=$input_arff;
$feaTUMfselfile=~ s/\.arff/.fselection/;
# count number of features first
$nStr = 0;
open(FILE,"<$outpArff");
while () {
my $line = $_; chop($line);
if ($line =~ /^\@attribute (.+?) numeric/) {
$nStr++;
}
if ($line =~ /^\@data/) { last; }
}
close(FILE);
open(OUT,">$feaTUMfselfile");
print OUT "str\n";
print OUT "$nStr\n";
open(FILE,"<$outpArff");
while () {
my $line = $_; chop($line);
if ($line =~ /^\@attribute (.+?) numeric/) {
$attr = $1;
print "selecting: $attr \n";
print OUT "$attr\n";
}
if ($line =~ /^\@data/) { last; }
}
close(FILE);
close(OUT);
opensmile-2.3.0/scripts/modeltrain/txtfile-functions.pl 0000660 0002002 0200001 00000003345 13004722023 022125 0 ustar fe audcore ###########################################################
# perl functions for simplified text file access #
# these functions read/write text files into/from arrays #
# by Florian Eyben, TUM, MMK (2008) #
###########################################################
# usage: @lines=readFile("filename");
sub readTextFile {
my @my_lines=();
if (-f "$_[0]") {
open(FILE,"<$_[0]");
@my_lines = ;
chop(@my_lines); # remove newline char.
close(FILE);
return @my_lines;
}
}
sub readTextFile_asString {
my @my_lines2=&readTextFile($_[0]);
my $my_tmp = join("\n",@my_lines2);
return "$my_tmp\n";
}
sub readTextFile_asRawString { # does NOT remove any newlines during reading...
my @my_lines=();
if (-f "$_[0]") {
open(FILE,"<$_[0]");
@my_lines = ;
close(FILE);
my $my_tmp = join("",@my_lines);
return "$my_tmp";
} else { return ""; }
}
# usage: &writeToTextFile(filename,$text) - save $text without appending \n at the end
# usage: &writeToTextFile(filename,@text) - save array joined by \n and with a \n after the last element (=line)
# caution: file will be overwritten if it exists!
sub writeToTextFile {
my $my_tmp = shift;
open(FILE,">$my_tmp");
if ($#_ > 0) { # array mode
print FILE join("\n",@_);
print FILE "\n";
} else { # string mode
print FILE "$_[0]";
}
close(FILE);
}
sub appendToTextFile {
my $my_tmp = shift;
if (-f $my_tmp) {
open(FILE,">>$my_tmp");
} else {
open(FILE,">$my_tmp");
}
if ($#_ > 0) { # array mode
print FILE join("\n",@_);
print FILE "\n";
} else { # string mode
print FILE "$_[0]";
}
close(FILE);
}
1; opensmile-2.3.0/scripts/modeltrain/buildmodel.pl 0000770 0002002 0200001 00000003327 13004722023 020562 0 ustar fe audcore #!/usr/bin/perl
# USAGE: buildmodel.pl [svm config file]
$input_lsvm = $ARGV[0];
$conf = $input_lsvm;
$conf =~ s/\.lsvm$/.config/;
$scale = $input_lsvm; $scale=~s/\.lsvm$/.scale/;
$scaled_lsvm = $input_lsvm; $scaled_lsvm =~ s/\.lsvm/.scaled.lsvm/;
$model = $input_lsvm; $model=~s/\.lsvm$/.model/;
if ($^O =~ /win/i) {
$ext = ".exe";
} else {
$ext = "";
}
# scale features, build model
unless (-e $scaled_lsvm) {
system("libsvm-small/svm-scale$ext -s $scale $input_lsvm > $scaled_lsvm");
}
$discfile = $input_lsvm; $discfile=~s/\.lsvm$/.disc/;
open(FILE,"<$discfile");
$disc=; $disc=~s/\r?\n$//;
close(FILE);
if ($disc) { # classification if disc==1
print " building an SVM CLASSFICATION model...\n";
#classification:
## change LibSVM parameters here, if you want to use a different configuration:
## See the LibSVM documentation for more information:
if (-e $ARGV[1]) {
$svm_config = `cat $ARGV[1]`;
$svm_config =~ s/\n//g;
$svm_config =~ s/\r//g;
} else {
$svm_config = "-b 1 -s 0 -t 1 -d 1 -c 0.3";
}
#system("libsvm-small/svm-train$ext -n 0.5 -b 1 -s 1 -t 1 -d 2 -c 0.7 $scaled_lsvm $model");
# Original:
system("libsvm-small/svm-train$ext $svm_config $scaled_lsvm $model");
} else { # regression otherwise:
print " building an SVR REGRESSION model...\n";
if (-e $ARGV[1]) {
$svm_config = `cat $ARGV[1]`;
$svm_config =~ s/\n//g;
$svm_config =~ s/\r//g;
} else {
$svm_config = "-s 3 -t 1 -d 1 -c 0.4";
}
##### regression:
## change LibSVM parameters here, if you want to use a different configuration:
## See the LibSVM documentation for more information:
system("svm-train$ext $svm_config $scaled_lsvm $model");
}
open(FILE,">$conf");
print FILE "$svm_config\n";
close(FILE);
opensmile-2.3.0/scripts/modeltrain/arff-standardize.c 0000660 0002002 0200001 00000054324 13004722023 021476 0 ustar fe audcore /*F***************************************************************************
*
* openSMILE - the Munich open source Multimedia Interpretation by
* Large-scale Extraction toolkit
*
* This file is part of openSMILE.
*
* openSMILE is copyright (c) by audEERING GmbH. All rights reserved.
*
* See file "COPYING" for details on usage rights and licensing terms.
* By using, copying, editing, compiling, modifying, reading, etc. this
* file, you agree to the licensing terms in the file COPYING.
* If you do not agree to the licensing terms,
* you must immediately destroy all copies of this file.
*
* THIS SOFTWARE COMES "AS IS", WITH NO WARRANTIES. THIS MEANS NO EXPRESS,
* IMPLIED OR STATUTORY WARRANTY, INCLUDING WITHOUT LIMITATION, WARRANTIES OF
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ANY WARRANTY AGAINST
* INTERFERENCE WITH YOUR ENJOYMENT OF THE SOFTWARE OR ANY WARRANTY OF TITLE
* OR NON-INFRINGEMENT. THERE IS NO WARRANTY THAT THIS SOFTWARE WILL FULFILL
* ANY OF YOUR PARTICULAR PURPOSES OR NEEDS. ALSO, YOU MUST PASS THIS
* DISCLAIMER ON WHENEVER YOU DISTRIBUTE THE SOFTWARE OR DERIVATIVE WORKS.
* NEITHER TUM NOR ANY CONTRIBUTOR TO THE SOFTWARE WILL BE LIABLE FOR ANY
* DAMAGES RELATED TO THE SOFTWARE OR THIS LICENSE AGREEMENT, INCLUDING
* DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL OR INCIDENTAL DAMAGES, TO THE
* MAXIMUM EXTENT THE LAW PERMITS, NO MATTER WHAT LEGAL THEORY IT IS BASED ON.
* ALSO, YOU MUST PASS THIS LIMITATION OF LIABILITY ON WHENEVER YOU DISTRIBUTE
* THE SOFTWARE OR DERIVATIVE WORKS.
*
* Main authors: Florian Eyben, Felix Weninger,
* Martin Woellmer, Bjoern Schuller
*
* Copyright (c) 2008-2013,
* Institute for Human-Machine Communication,
* Technische Universitaet Muenchen, Germany
*
* Copyright (c) 2013-2015,
* audEERING UG (haftungsbeschraenkt),
* Gilching, Germany
*
* Copyright (c) 2016,
* audEERING GmbH,
* Gilching Germany
***************************************************************************E*/
/*
read in one ARFF file, compute mean and variance and standardize + save normadta
compute mean and variance
*/
#include
#include
#include
#include
#include
#include
#include
typedef struct {
long dim;
float *x;
} sVectorFloat;
typedef sVectorFloat * vectorFloat;
typedef struct {
long dim;
double *x;
} sVectorDouble;
typedef sVectorDouble * vectorDouble;
typedef struct {
long dim;
void *x;
} sVector;
typedef sVector * vector;
typedef struct {
int nDim;
long *dim;
long long els;
float *x;
} sMatrixFloat;
typedef sMatrixFloat * matrixFloat;
typedef struct {
long rows, cols;
long long els;
float *x;
} sMatrix2DFloat;
typedef sMatrix2DFloat * matrix2DFloat;
inline vector vectorCreate(long dim, int elSize) // elSize : size of vector element in bytes
{
vector ret = (vector)malloc(sizeof(sVector));
if (ret == NULL) return NULL;
ret->x = calloc(1,elSize*dim);
ret->dim = dim;
return ret;
}
inline vectorFloat vectorFloatCreate(long dim)
{
vectorFloat ret = (vectorFloat)malloc(sizeof(sVectorFloat));
if (ret == NULL) return NULL;
ret->x = (float *)calloc(1,sizeof(float)*dim);
ret->dim = dim;
return ret;
}
inline vectorDouble vectorDoubleCreate(long dim)
{
vectorDouble ret = (vectorDouble)malloc(sizeof(sVectorDouble));
if (ret == NULL) return NULL;
ret->x = (double *)calloc(1,sizeof(double)*dim);
ret->dim = dim;
return ret;
}
inline vectorFloat vectorFloatDestroy(vectorFloat vec)
{
if (vec != NULL) {
if (vec->x != NULL) free(vec->x);
free(vec);
}
return NULL;
}
inline vectorDouble vectorDoubleDestroy(vectorDouble vec)
{
if (vec != NULL) {
if (vec->x != NULL) free(vec->x);
free(vec);
}
return NULL;
}
matrixFloat matrixFloatCreate(int nDim, long *dim)
{
int i;
matrixFloat ret = (matrixFloat)malloc(sizeof(sMatrixFloat));
if (ret == NULL) return NULL;
ret->els = 1;
for (i=0; iels *= dim[i];
}
ret->x = (float *)calloc(1,sizeof(float)*ret->els);
ret->dim = dim;
return ret;
}
matrix2DFloat matrix2DFloatCreate(long rows, long cols)
{
matrix2DFloat ret = (matrix2DFloat)malloc(sizeof(sMatrix2DFloat));
if (ret == NULL) return NULL;
ret->els = rows*cols;
ret->rows = rows;
ret->cols = cols;
ret->x = (float *)calloc(1,sizeof(float)*ret->els);
return ret;
}
matrix2DFloat matrix2DFloatDestroy(matrix2DFloat mat)
{
if (mat == NULL) return NULL;
if (mat->x != NULL) free(mat->x);
free(mat);
return NULL;
}
inline float minFloat(float a, float b)
{
if (a < b) return a;
else return b;
}
inline long minLong(long a, long b)
{
if (a < b) return a;
else return b;
}
vectorFloat getMatrix2DFloatRow(matrix2DFloat mat, long row)
{
if ((mat != NULL)&&(mat->x != NULL)) {
vectorFloat r = vectorFloatCreate(mat->cols);
if (r == NULL) return NULL;
memcpy(r->x, mat->x + (row * (mat->cols)), (mat->cols) * sizeof(float));
return r;
}
return NULL;
}
void setMatrix2DFloatRow(matrix2DFloat mat, long row, vectorFloat r)
{
if ((mat != NULL)&&(mat->x != NULL)) {
if (r == NULL) return;
memcpy(mat->x + (row * (mat->cols)), r->x , (mat->cols) * sizeof(float));
}
}
// add vector b onto vector a
void vectorFloatAdd(vectorFloat a, vectorFloat b)
{
if ((a!= NULL)&&(a->x != NULL)&&(b!= NULL)&&(b->x != NULL)) {
long i;
long lng = minLong(a->dim, b->dim);
for (i=0; ix[i] += b->x[i];
}
}
}
// subtract vector b from vector a
void vectorFloatSub(vectorFloat a, vectorFloat b)
{
if ((a!= NULL)&&(a->x != NULL)&&(b!= NULL)&&(b->x != NULL)) {
long i;
long lng = minLong(a->dim, b->dim);
for (i=0; ix[i] -= b->x[i];
}
}
}
// add vector b onto vector a
void vectorDoubleAdd(vectorDouble a, vectorDouble b)
{
if ((a!= NULL)&&(a->x != NULL)&&(b!= NULL)&&(b->x != NULL)) {
long i;
long lng = minLong(a->dim, b->dim);
for (i=0; ix[i] += b->x[i];
}
}
}
// subtract vector b from vector a
void vectorDoubleSub(vectorDouble a, vectorDouble b)
{
if ((a!= NULL)&&(a->x != NULL)&&(b!= NULL)&&(b->x != NULL)) {
long i;
long lng = minLong(a->dim, b->dim);
for (i=0; ix[i] -= b->x[i];
}
}
}
// divide elements in vector a by corresponding elements in vector b, save in a
void vectorFloatElemDiv(vectorFloat a, vectorFloat b)
{
if ((a!= NULL)&&(a->x != NULL)&&(b!= NULL)&&(b->x != NULL)) {
long i;
long lng = minLong(a->dim, b->dim);
for (i=0; ix[i] /= b->x[i];
}
}
}
// divide elements in vector a by corresponding elements in vector b, save in a
void vectorDoubleElemDiv(vectorDouble a, vectorDouble b)
{
if ((a!= NULL)&&(a->x != NULL)&&(b!= NULL)&&(b->x != NULL)) {
long i;
long lng = minLong(a->dim, b->dim);
for (i=0; ix[i] /= b->x[i];
}
}
}
// divide elements in vector a by corresponding elements in vector b, save in a
// SAFE: do not dived by 0, result will then be 0
void vectorDoubleElemSafeDiv(vectorDouble a, vectorDouble b)
{
if ((a!= NULL)&&(a->x != NULL)&&(b!= NULL)&&(b->x != NULL)) {
long i;
long lng = minLong(a->dim, b->dim);
for (i=0; ix[i] != 0.0)
a->x[i] /= b->x[i];
else
a->x[i] = 0.0;
}
}
}
vectorDouble vectorFloatToVectorDouble(vectorFloat a)
{
if ((a!= NULL)&&(a->x != NULL)) {
long i;
vectorDouble d = vectorDoubleCreate(a->dim);
if (d==NULL) return NULL;
for (i=0; idim; i++) {
d->x[i] = (double)(a->x[i]);
}
return d;
}
return NULL;
}
vectorFloat vectorDoubleToVectorFloat(vectorDouble a)
{
if ((a!= NULL)&&(a->x != NULL)) {
long i;
vectorFloat d = vectorFloatCreate(a->dim);
if (d==NULL) return NULL;
for (i=0; idim; i++) {
d->x[i] = (float)(a->x[i]);
}
return d;
}
return NULL;
}
void vectorDoubleScalarDiv(vectorDouble vec, long long n)
{
if ((vec != NULL)&&(vec->x != NULL)) {
long i;
double nD = (double)n;
for (i=0; idim; i++) {
vec->x[i] /= nD;
}
}
}
void vectorDoubleElemSqrt(vectorDouble vec)
{
if ((vec != NULL)&&(vec->x != NULL)) {
long i;
for (i=0; idim; i++) {
vec->x[i] = sqrt(vec->x[i]);
}
}
}
void vectorDoubleElemSqr(vectorDouble vec)
{
if ((vec != NULL)&&(vec->x != NULL)) {
long i;
for (i=0; idim; i++) {
vec->x[i] = vec->x[i] * vec->x[i];
}
}
}
vectorFloat columnSum (matrix2DFloat mat)
{
long i,j;
if ((mat != NULL)&&(mat->x != NULL)) {
vectorFloat v = getMatrix2DFloatRow(mat,0);
for(i=1; irows; i++) {
vectorFloat r = getMatrix2DFloatRow(mat,i);
vectorFloatAdd(v,r);
vectorFloatDestroy(r);
}
return v;
}
return NULL;
}
vectorDouble columnVarianceSum (matrix2DFloat mat, vectorDouble means)
{
long i,j;
if ((mat != NULL)&&(mat->x != NULL)) {
vectorFloat vf = getMatrix2DFloatRow(mat,0);
vectorDouble v = vectorFloatToVectorDouble(vf);
vf = vectorFloatDestroy(vf);
for(i=1; irows; i++) {
vectorFloat r = getMatrix2DFloatRow(mat,i);
vectorDouble rD = vectorFloatToVectorDouble(r);
vectorFloatDestroy(r);
vectorDoubleSub(rD,means);
vectorDoubleElemSqr(rD);
vectorDoubleAdd(v,rD);
vectorDoubleDestroy(rD);
}
return v;
}
return NULL;
}
void matRowsNormaliseMean (matrix2DFloat mat, vectorFloat mean)
{
long i,j;
if ((mat != NULL)&&(mat->x != NULL)) {
for(i=0; irows; i++) {
vectorFloat r = getMatrix2DFloatRow(mat,i);
vectorFloatSub(r,mean);
setMatrix2DFloatRow(mat,i,r);
vectorFloatDestroy(r);
}
}
}
void matRowsStandardiseVariance (matrix2DFloat mat, vectorFloat stddev)
{
long i,j;
if ((mat != NULL)&&(mat->x != NULL)) {
for(i=0; irows; i++) {
vectorFloat r = getMatrix2DFloatRow(mat,i);
vectorFloatElemDiv(r,stddev);
setMatrix2DFloatRow(mat,i,r);
vectorFloatDestroy(r);
}
}
}
#include
#define MIN_LOG_STRLEN 255
/* allocate a string and expand vararg format string expression into it */
// WARNING: memory allocated by myvprint must freed by the code calling myvprint!!
char *myvprint(const char *fmt, ...) {
char *s= (char *)malloc(sizeof(char)*(MIN_LOG_STRLEN+1));
if (s==NULL) return NULL;
va_list ap;
va_start(ap, fmt);
int len = vsnprintf(s,MIN_LOG_STRLEN+1, fmt, ap);
if (len > MIN_LOG_STRLEN) {
free(s);
s = (char *)malloc(sizeof(char)*len+2);
va_start(ap, fmt);
len = vsnprintf(s,len+1, fmt, ap);
}
va_end(ap);
return s;
}
// matRowsNormaliseMean(data,mean);
// matRowsStandardiseVariance(data,stddev);
int main(int argc, char *argv[])
{
if (argc < 5) {
fprintf(stderr, "USAGE: %s [normdata.dat_file_to_load OR -normdata_file_to_saveTo]\n",argv[0]);
return -1;
}
vectorDouble sum = NULL;
vectorDouble var = NULL;
vectorDouble mean = NULL;
vectorDouble stddev = NULL;
vectorFloat meanF = NULL;
vectorFloat stddevF = NULL;
long long n = 0;
FILE *iarff;
int startft = atoi(argv[3]);
int endft = atoi(argv[4]);
if ((argc == 5)||(argv[5][0]=='-')) { // no normdata file given, create normadata from input arff
/*** mean ****/
iarff = fopen(argv[1],"r");
int read;
char *line=NULL;
char *nline=NULL;
size_t len=0;
int data = 0;
int Natt = 0;
while ((read = getline(&line, &len, iarff)) != -1) {
int llen = strlen(line);
if (llen <= 0) continue;
//printf("llen=%i\n",llen);
if (line[llen-1] == '\n') {
line[llen-1] = 0; // strip \n character
llen--;
}
if (llen <= 0) continue;
if (line[llen-1] == '\r') {
line[llen-1] = 0; // strip \r character
llen--;
}
if (llen <= 0) continue;
// ignore non-data lines...
if (data == 0) {
if (llen >= 5) {
data = 1;
if (line[0] != '@') data = 0;
else if (line[1] != 'd') data = 0;
else if (line[2] != 'a') data = 0;
else if (line[3] != 't') data = 0;
else if (line[4] != 'a') data = 0;
//printf("data=%i line='%s'\n",data,line);
}
if (llen >= 10) {
int att = 1;
if (line[0] != '@') att = 0;
else if (line[1] != 'a') att = 0;
else if (line[2] != 't') att = 0;
else if (line[3] != 't') att = 0;
else if (line[4] != 'r') att = 0;
else if (line[5] != 'i') att = 0;
else if (line[6] != 'b') att = 0;
else if (line[7] != 'u') att = 0;
else if (line[8] != 't') att = 0;
else if (line[9] != 'e') att = 0;
if (att) Natt++;
}
nline = NULL;
} else {
nline = line;
// remove spaces
while ((llen>0)&&(nline[0]==' ')) { nline++; llen--; }
while ((llen>0)&&(nline[llen-1]==' ')) { nline[llen-1]=0; llen--; }
// convert line to vecotr
char *el=NULL;
int vlen = (Natt-endft)-startft+1;
vectorDouble d = vectorDoubleCreate(vlen);
if (sum == NULL) {
sum = vectorDoubleCreate(vlen);
printf("create sum vlen=%i\n",vlen); fflush(stdout);
}
int fti=1;
if (llen > 0) {
do {
el=strchr(nline,',');
if (el!=NULL)
el[0] = 0;
if (fti>=startft)
if (ftix[fti-startft] = atof(nline);
fti++;
if (el!=NULL) {
nline = el+1;
}
} while (el!=NULL);
}
if (fti-startft < vlen) { printf("warning: less elements on line than expected!!\n"); }
// add vector to sum...
vectorDoubleAdd(sum,d);
vectorDoubleDestroy(d);
n++;
}
free(line); line=NULL;
}
fclose(iarff);
// compute means:
if (n>0)
vectorDoubleScalarDiv(sum,n);
mean = sum;
/**** variance ****/
vectorDouble var = NULL;
iarff = fopen(argv[1],"r");
read = 0;
line=NULL;
nline=NULL;
len=0;
data = 0;
Natt = 0;
while ((read = getline(&line, &len, iarff)) != -1) {
int llen = strlen(line);
if (llen <= 0) continue;
if (line[llen-1] == '\n') {
line[llen-1] = 0; // strip \n character
llen--;
}
if (llen <= 0) continue;
if (line[llen-1] == '\r') {
line[llen-1] = 0; // strip \r character
llen--;
}
if (llen <= 0) continue;
// ignore non-data lines...
if (data == 0) {
if (llen >= 5) {
data = 1;
if (line[0] != '@') data = 0;
else if (line[1] != 'd') data = 0;
else if (line[2] != 'a') data = 0;
else if (line[3] != 't') data = 0;
else if (line[4] != 'a') data = 0;
}
if (llen >= 10) {
int att = 1;
if (line[0] != '@') att = 0;
else if (line[1] != 'a') att = 0;
else if (line[2] != 't') att = 0;
else if (line[3] != 't') att = 0;
else if (line[4] != 'r') att = 0;
else if (line[5] != 'i') att = 0;
else if (line[6] != 'b') att = 0;
else if (line[7] != 'u') att = 0;
else if (line[8] != 't') att = 0;
else if (line[9] != 'e') att = 0;
if (att) Natt++;
}
nline = NULL;
} else {
nline = line;
// remove spaces
while ((llen>0)&&(nline[0]==' ')) { nline++; llen--; }
while ((llen>0)&&(nline[llen-1]==' ')) { nline[llen-1]=0; llen--; }
// convert line to vecotr
char *el=NULL;
int vlen = (Natt-endft)-startft+1;
vectorDouble d = vectorDoubleCreate(vlen);
if (var == NULL) {
var = vectorDoubleCreate(vlen);
}
int fti=1;
if (llen > 0) {
do {
el=strchr(nline,',');
if (el != NULL)
el[0] = 0;
if (fti>=startft)
if (ftix[fti-startft] = atof(nline);
fti++;
if (el!=NULL) {
nline = el+1;
}
} while (el!=NULL);
}
if (fti-startft < vlen) { printf("warning: less elements on line than expected!!\n"); }
// add vector var to variance sum...
//...
vectorDoubleSub(d,mean);
vectorDoubleElemSqr(d);
vectorDoubleAdd(var,d);
vectorDoubleDestroy(d); d=NULL;
//n++;
}
free(line); line=NULL;
}
fclose(iarff);
if (n>0)
vectorDoubleScalarDiv(var,n);
stddev = var;
vectorDoubleElemSqrt(stddev);
//printf("var0: %f (dim=%i)\n",var->x[0],var->dim);
// save normdata file in current path
FILE *nd ;
if ((argc>5)&&(argv[5][0]=='-')) {
nd = fopen((argv[5]+1),"wb");
} else {
nd = fopen("normdata.dat","wb");
}
if (nd != NULL) {
fwrite(mean->x, sizeof(double)*mean->dim, 1, nd);
fwrite(stddev->x, sizeof(double)*stddev->dim, 1, nd);
fclose(nd);
} else {
fprintf(stderr,"ERROR saving normdata\n");
}
//meanF = vectorDoubleToVectorFloat(mean);
//stddevF = vectorDoubleToVectorFloat(stddev);
}
/* do actual standardisation::: */
/***************************************************************************/
FILE * oarff=NULL;
iarff = fopen(argv[1],"r");
if (!(argv[2][0] == '-')) {
oarff = fopen(argv[2],"w");
} else {
char *tmp = myvprint("%s.norm.arff",argv[1]);
oarff = fopen(tmp,"w");
free(tmp);
}
int read = 0;
char *line=NULL;
char *nline=NULL;
size_t len=0;
int data = 0;
int Natt = 0;
while ((read = getline(&line, &len, iarff)) != -1) {
int llen = strlen(line);
if (line[llen-1] == '\n') {
line[llen-1] = 0; // strip \n character
llen--;
}
if (line[llen-1] == '\r') {
line[llen-1] = 0; // strip \r character
llen--;
}
// ignore non-data lines...
if (data == 0) {
if (llen >= 5) {
data = 1;
if (line[0] != '@') data = 0;
else if (line[1] != 'd') data = 0;
else if (line[2] != 'a') data = 0;
else if (line[3] != 't') data = 0;
else if (line[4] != 'a') data = 0;
}
if (llen >= 10) {
int att = 1;
if (line[0] != '@') att = 0;
else if (line[1] != 'a') att = 0;
else if (line[2] != 't') att = 0;
else if (line[3] != 't') att = 0;
else if (line[4] != 'r') att = 0;
else if (line[5] != 'i') att = 0;
else if (line[6] != 'b') att = 0;
else if (line[7] != 'u') att = 0;
else if (line[8] != 't') att = 0;
else if (line[9] != 'e') att = 0;
if (att) Natt++;
}
nline = NULL;
fprintf(oarff,"%s\n",line);
} else {
int vlen = (Natt-endft)-startft+1;
if ((mean == NULL)&&(argc > 5)) {
mean = vectorDoubleCreate(vlen);
stddev = vectorDoubleCreate(vlen);
// FILE *nd = fopen("normdata.dat","rb");
FILE *nd = fopen(argv[5],"rb");
if (nd != NULL) {
fread(mean->x, sizeof(double)*mean->dim, 1, nd);
fread(stddev->x, sizeof(double)*stddev->dim, 1, nd);
fclose(nd);
} else {
fprintf(stderr,"ERROR loading normdata\n");
}
}
nline = line;
// remove spaces
while ((llen>0)&&(nline[0]==' ')) { nline++; llen--; }
while ((llen>0)&&(nline[llen-1]==' ')) { nline[llen-1]=0; llen--; }
// convert line to vecotr
char *el=NULL;
vectorDouble d = vectorDoubleCreate(vlen);
if (var == NULL) {
var = vectorDoubleCreate(vlen);
}
int fti=1;
char *oline0=NULL;
char *oline1=NULL;
char *oline0e=NULL;
char *oline1e=NULL;
if (llen > 0) {
do {
el=strchr(nline,',');
if (el!=NULL)
el[0] = 0;
if (fti>=startft)
if (ftix[fti-startft] = atof(nline);
else {
if (oline0e != NULL) {
oline1e = myvprint("%s,%s",oline0e,nline);
free(oline0e); oline0e=oline1e;
} else {
oline0e = strdup(nline);
}
}
else {
if (oline0 != NULL) {
oline1 = myvprint("%s,%s",oline0,nline);
free(oline0); oline0=oline1;
} else {
oline0 = strdup(nline);
}
}
fti++;
if (el!=NULL) {
nline = el+1;
}
} while (el!=NULL);
if (fti-startft < vlen) { printf("warning: less elements on line than expected!!\n"); }
// add vector var to variance sum...
//...
vectorDoubleSub(d,mean);
vectorDoubleElemSafeDiv(d,stddev);
// rebuild line and write to file...
int prev = 0;
if (oline0 != NULL) {
fprintf(oarff,"%s",oline0);
free(oline0);
prev = 1;
}
long i;
for (i=0; ix[i]);
else
fprintf(oarff,"%f",d->x[i]);
prev = 1;
}
if (oline0e != NULL) {
if (prev) fprintf(oarff,",");
fprintf(oarff,"%s",oline0e);
free(oline0e);
}
fprintf(oarff,"\n");
/*
char *oline=strdup(oline0);
int i;
for (i=0; ix[i]);
free(oline); oline=tmp;
}
char *tmp = myvprint("%s,%s",oline,oline0e);
free(oline); oline=tmp;
fprintf(oarff,"%s\n",oline);*/
//n++;
}
}
free(line); line=NULL;
}
fclose(oarff);
fclose(iarff);
vectorDoubleDestroy(mean); // at the end...
vectorDoubleDestroy(stddev);
vectorFloatDestroy(meanF); // at the end...
vectorFloatDestroy(stddevF);
//printf("Hello World!\n");
}
opensmile-2.3.0/scripts/modeltrain/libsvm-small/ 0000770 0002002 0200001 00000000000 13004722023 020477 5 ustar fe audcore opensmile-2.3.0/scripts/modeltrain/libsvm-small/svm.h 0000660 0002002 0200001 00000004325 13004722023 021462 0 ustar fe audcore #ifndef _LIBSVM_H
#define _LIBSVM_H
#define LIBSVM_VERSION 289
#ifdef __cplusplus
extern "C" {
#endif
extern int libsvm_version;
struct svm_node
{
int index;
double value;
};
struct svm_problem
{
int l;
double *y;
struct svm_node **x;
};
enum { C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR }; /* svm_type */
enum { LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED }; /* kernel_type */
struct svm_parameter
{
int svm_type;
int kernel_type;
int degree; /* for poly */
double gamma; /* for poly/rbf/sigmoid */
double coef0; /* for poly/sigmoid */
/* these are for training only */
double cache_size; /* in MB */
double eps; /* stopping criteria */
double C; /* for C_SVC, EPSILON_SVR and NU_SVR */
int nr_weight; /* for C_SVC */
int *weight_label; /* for C_SVC */
double* weight; /* for C_SVC */
double nu; /* for NU_SVC, ONE_CLASS, and NU_SVR */
double p; /* for EPSILON_SVR */
int shrinking; /* use the shrinking heuristics */
int probability; /* do probability estimates */
};
struct svm_model *svm_train(const struct svm_problem *prob, const struct svm_parameter *param);
void svm_cross_validation(const struct svm_problem *prob, const struct svm_parameter *param, int nr_fold, double *target);
int svm_save_model(const char *model_file_name, const struct svm_model *model);
struct svm_model *svm_load_model(const char *model_file_name);
int svm_get_svm_type(const struct svm_model *model);
int svm_get_nr_class(const struct svm_model *model);
void svm_get_labels(const struct svm_model *model, int *label);
double svm_get_svr_probability(const struct svm_model *model);
void svm_predict_values(const struct svm_model *model, const struct svm_node *x, double* dec_values);
double svm_predict(const struct svm_model *model, const struct svm_node *x);
double svm_predict_probability(const struct svm_model *model, const struct svm_node *x, double* prob_estimates);
void svm_destroy_model(struct svm_model *model);
void svm_destroy_param(struct svm_parameter *param);
const char *svm_check_parameter(const struct svm_problem *prob, const struct svm_parameter *param);
int svm_check_probability_model(const struct svm_model *model);
extern void (*svm_print_string) (const char *);
#ifdef __cplusplus
}
#endif
#endif /* _LIBSVM_H */
opensmile-2.3.0/scripts/modeltrain/libsvm-small/Makefile 0000660 0002002 0200001 00000000770 13004722023 022144 0 ustar fe audcore CXX = g++
CFLAGS = -Wall -static -Wconversion -O3 -fPIC
SHVER = 1
all: svm-train svm-predict svm-scale
lib: svm.o
$(CXX) -shared svm.o -o libsvm.so.$(SHVER)
svm-predict: svm-predict.c svm.o
$(CXX) $(CFLAGS) svm-predict.c svm.o -o svm-predict -lm
svm-train: svm-train.c svm.o
$(CXX) $(CFLAGS) svm-train.c svm.o -o svm-train -lm
svm-scale: svm-scale.c
$(CXX) $(CFLAGS) svm-scale.c -o svm-scale
svm.o: svm.cpp svm.h
$(CXX) $(CFLAGS) -c svm.cpp
clean:
rm -f *~ svm.o svm-train svm-predict svm-scale
opensmile-2.3.0/scripts/modeltrain/libsvm-small/svm-train.c 0000660 0002002 0200001 00000020576 13004722023 022576 0 ustar fe audcore #include
#include
#include
#include
#include
#include "svm.h"
#define Malloc(type,n) (type *)malloc((n)*sizeof(type))
void print_null(const char *s) {}
void exit_with_help()
{
printf(
"Usage: svm-train [options] training_set_file [model_file]\n"
"options:\n"
"-s svm_type : set type of SVM (default 0)\n"
" 0 -- C-SVC\n"
" 1 -- nu-SVC\n"
" 2 -- one-class SVM\n"
" 3 -- epsilon-SVR\n"
" 4 -- nu-SVR\n"
"-t kernel_type : set type of kernel function (default 2)\n"
" 0 -- linear: u'*v\n"
" 1 -- polynomial: (gamma*u'*v + coef0)^degree\n"
" 2 -- radial basis function: exp(-gamma*|u-v|^2)\n"
" 3 -- sigmoid: tanh(gamma*u'*v + coef0)\n"
" 4 -- precomputed kernel (kernel values in training_set_file)\n"
"-d degree : set degree in kernel function (default 3)\n"
"-g gamma : set gamma in kernel function (default 1/k)\n"
"-r coef0 : set coef0 in kernel function (default 0)\n"
"-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)\n"
"-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)\n"
"-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)\n"
"-m cachesize : set cache memory size in MB (default 100)\n"
"-e epsilon : set tolerance of termination criterion (default 0.001)\n"
"-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)\n"
"-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)\n"
"-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)\n"
"-v n: n-fold cross validation mode\n"
"-q : quiet mode (no outputs)\n"
);
exit(1);
}
void exit_input_error(int line_num)
{
fprintf(stderr,"Wrong input format at line %d\n", line_num);
exit(1);
}
void parse_command_line(int argc, char **argv, char *input_file_name, char *model_file_name);
void read_problem(const char *filename);
void do_cross_validation();
struct svm_parameter param; // set by parse_command_line
struct svm_problem prob; // set by read_problem
struct svm_model *model;
struct svm_node *x_space;
int cross_validation;
int nr_fold;
static char *line = NULL;
static int max_line_len;
static char* readline(FILE *input)
{
int len;
if(fgets(line,max_line_len,input) == NULL)
return NULL;
while(strrchr(line,'\n') == NULL)
{
max_line_len *= 2;
line = (char *) realloc(line,max_line_len);
len = (int) strlen(line);
if(fgets(line+len,max_line_len-len,input) == NULL)
break;
}
return line;
}
int main(int argc, char **argv)
{
char input_file_name[1024];
char model_file_name[1024];
const char *error_msg;
parse_command_line(argc, argv, input_file_name, model_file_name);
read_problem(input_file_name);
error_msg = svm_check_parameter(&prob,¶m);
if(error_msg)
{
fprintf(stderr,"Error: %s\n",error_msg);
exit(1);
}
if(cross_validation)
{
do_cross_validation();
}
else
{
model = svm_train(&prob,¶m);
svm_save_model(model_file_name,model);
svm_destroy_model(model);
}
svm_destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
free(line);
return 0;
}
void do_cross_validation()
{
int i;
int total_correct = 0;
double total_error = 0;
double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
double *target = Malloc(double,prob.l);
svm_cross_validation(&prob,¶m,nr_fold,target);
if(param.svm_type == EPSILON_SVR ||
param.svm_type == NU_SVR)
{
for(i=0;i=argc)
exit_with_help();
switch(argv[i-1][1])
{
case 's':
param.svm_type = atoi(argv[i]);
break;
case 't':
param.kernel_type = atoi(argv[i]);
break;
case 'd':
param.degree = atoi(argv[i]);
break;
case 'g':
param.gamma = atof(argv[i]);
break;
case 'r':
param.coef0 = atof(argv[i]);
break;
case 'n':
param.nu = atof(argv[i]);
break;
case 'm':
param.cache_size = atof(argv[i]);
break;
case 'c':
param.C = atof(argv[i]);
break;
case 'e':
param.eps = atof(argv[i]);
break;
case 'p':
param.p = atof(argv[i]);
break;
case 'h':
param.shrinking = atoi(argv[i]);
break;
case 'b':
param.probability = atoi(argv[i]);
break;
case 'q':
svm_print_string = &print_null;
i--;
break;
case 'v':
cross_validation = 1;
nr_fold = atoi(argv[i]);
if(nr_fold < 2)
{
fprintf(stderr,"n-fold cross validation: n must >= 2\n");
exit_with_help();
}
break;
case 'w':
++param.nr_weight;
param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight);
param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight);
param.weight_label[param.nr_weight-1] = atoi(&argv[i-1][2]);
param.weight[param.nr_weight-1] = atof(argv[i]);
break;
default:
fprintf(stderr,"Unknown option: -%c\n", argv[i-1][1]);
exit_with_help();
}
}
// determine filenames
if(i>=argc)
exit_with_help();
strcpy(input_file_name, argv[i]);
if(i start from 0
readline(fp);
prob.x[i] = &x_space[j];
label = strtok(line," \t");
prob.y[i] = strtod(label,&endptr);
if(endptr == label)
exit_input_error(i+1);
while(1)
{
idx = strtok(NULL,":");
val = strtok(NULL," \t");
if(val == NULL)
break;
errno = 0;
x_space[j].index = (int) strtol(idx,&endptr,10);
if(endptr == idx || errno != 0 || *endptr != '\0' || x_space[j].index <= inst_max_index)
exit_input_error(i+1);
else
inst_max_index = x_space[j].index;
errno = 0;
x_space[j].value = strtod(val,&endptr);
if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
exit_input_error(i+1);
++j;
}
if(inst_max_index > max_index)
max_index = inst_max_index;
x_space[j++].index = -1;
}
if(param.gamma == 0 && max_index > 0)
param.gamma = 1.0/max_index;
if(param.kernel_type == PRECOMPUTED)
for(i=0;i max_index)
{
fprintf(stderr,"Wrong input format: sample_serial_number out of range\n");
exit(1);
}
}
fclose(fp);
}
opensmile-2.3.0/scripts/modeltrain/libsvm-small/svm.cpp 0000660 0002002 0200001 00000171721 13004722023 022022 0 ustar fe audcore #include
#include
#include
#include
#include
#include
#include
#include "svm.h"
int libsvm_version = LIBSVM_VERSION;
typedef float Qfloat;
typedef signed char schar;
#ifndef min
template inline T min(T x,T y) { return (x inline T max(T x,T y) { return (x>y)?x:y; }
#endif
template inline void swap(T& x, T& y) { T t=x; x=y; y=t; }
template inline void clone(T*& dst, S* src, int n)
{
dst = new T[n];
memcpy((void *)dst,(void *)src,sizeof(T)*n);
}
inline double powi(double base, int times)
{
double tmp = base, ret = 1.0;
for(int t=times; t>0; t/=2)
{
if(t%2==1) ret*=tmp;
tmp = tmp * tmp;
}
return ret;
}
#define INF HUGE_VAL
#define TAU 1e-12
#define Malloc(type,n) (type *)malloc((n)*sizeof(type))
static void print_string_stdout(const char *s)
{
fputs(s,stdout);
fflush(stdout);
}
void (*svm_print_string) (const char *) = &print_string_stdout;
#if 1
static void info(const char *fmt,...)
{
char buf[BUFSIZ];
va_list ap;
va_start(ap,fmt);
vsprintf(buf,fmt,ap);
va_end(ap);
(*svm_print_string)(buf);
}
#else
static void info(const char *fmt,...) {}
#endif
//
// Kernel Cache
//
// l is the number of total data items
// size is the cache size limit in bytes
//
class Cache
{
public:
Cache(int l,long int size);
~Cache();
// request data [0,len)
// return some position p where [p,len) need to be filled
// (p >= len if nothing needs to be filled)
int get_data(const int index, Qfloat **data, int len);
void swap_index(int i, int j);
private:
int l;
long int size;
struct head_t
{
head_t *prev, *next; // a circular list
Qfloat *data;
int len; // data[0,len) is cached in this entry
};
head_t *head;
head_t lru_head;
void lru_delete(head_t *h);
void lru_insert(head_t *h);
};
Cache::Cache(int l_,long int size_):l(l_),size(size_)
{
head = (head_t *)calloc(l,sizeof(head_t)); // initialized to 0
size /= sizeof(Qfloat);
size -= l * sizeof(head_t) / sizeof(Qfloat);
size = max(size, 2 * (long int) l); // cache must be large enough for two columns
lru_head.next = lru_head.prev = &lru_head;
}
Cache::~Cache()
{
for(head_t *h = lru_head.next; h != &lru_head; h=h->next)
free(h->data);
free(head);
}
void Cache::lru_delete(head_t *h)
{
// delete from current location
h->prev->next = h->next;
h->next->prev = h->prev;
}
void Cache::lru_insert(head_t *h)
{
// insert to last position
h->next = &lru_head;
h->prev = lru_head.prev;
h->prev->next = h;
h->next->prev = h;
}
int Cache::get_data(const int index, Qfloat **data, int len)
{
head_t *h = &head[index];
if(h->len) lru_delete(h);
int more = len - h->len;
if(more > 0)
{
// free old space
while(size < more)
{
head_t *old = lru_head.next;
lru_delete(old);
free(old->data);
size += old->len;
old->data = 0;
old->len = 0;
}
// allocate new space
h->data = (Qfloat *)realloc(h->data,sizeof(Qfloat)*len);
size -= more;
swap(h->len,len);
}
lru_insert(h);
*data = h->data;
return len;
}
void Cache::swap_index(int i, int j)
{
if(i==j) return;
if(head[i].len) lru_delete(&head[i]);
if(head[j].len) lru_delete(&head[j]);
swap(head[i].data,head[j].data);
swap(head[i].len,head[j].len);
if(head[i].len) lru_insert(&head[i]);
if(head[j].len) lru_insert(&head[j]);
if(i>j) swap(i,j);
for(head_t *h = lru_head.next; h!=&lru_head; h=h->next)
{
if(h->len > i)
{
if(h->len > j)
swap(h->data[i],h->data[j]);
else
{
// give up
lru_delete(h);
free(h->data);
size += h->len;
h->data = 0;
h->len = 0;
}
}
}
}
//
// Kernel evaluation
//
// the static method k_function is for doing single kernel evaluation
// the constructor of Kernel prepares to calculate the l*l kernel matrix
// the member function get_Q is for getting one column from the Q Matrix
//
class QMatrix {
public:
virtual Qfloat *get_Q(int column, int len) const = 0;
virtual Qfloat *get_QD() const = 0;
virtual void swap_index(int i, int j) const = 0;
virtual ~QMatrix() {}
};
class Kernel: public QMatrix {
public:
Kernel(int l, svm_node * const * x, const svm_parameter& param);
virtual ~Kernel();
static double k_function(const svm_node *x, const svm_node *y,
const svm_parameter& param);
virtual Qfloat *get_Q(int column, int len) const = 0;
virtual Qfloat *get_QD() const = 0;
virtual void swap_index(int i, int j) const // no so const...
{
swap(x[i],x[j]);
if(x_square) swap(x_square[i],x_square[j]);
}
protected:
double (Kernel::*kernel_function)(int i, int j) const;
private:
const svm_node **x;
double *x_square;
// svm_parameter
const int kernel_type;
const int degree;
const double gamma;
const double coef0;
static double dot(const svm_node *px, const svm_node *py);
double kernel_linear(int i, int j) const
{
return dot(x[i],x[j]);
}
double kernel_poly(int i, int j) const
{
return powi(gamma*dot(x[i],x[j])+coef0,degree);
}
double kernel_rbf(int i, int j) const
{
return exp(-gamma*(x_square[i]+x_square[j]-2*dot(x[i],x[j])));
}
double kernel_sigmoid(int i, int j) const
{
return tanh(gamma*dot(x[i],x[j])+coef0);
}
double kernel_precomputed(int i, int j) const
{
return x[i][(int)(x[j][0].value)].value;
}
};
Kernel::Kernel(int l, svm_node * const * x_, const svm_parameter& param)
:kernel_type(param.kernel_type), degree(param.degree),
gamma(param.gamma), coef0(param.coef0)
{
switch(kernel_type)
{
case LINEAR:
kernel_function = &Kernel::kernel_linear;
break;
case POLY:
kernel_function = &Kernel::kernel_poly;
break;
case RBF:
kernel_function = &Kernel::kernel_rbf;
break;
case SIGMOID:
kernel_function = &Kernel::kernel_sigmoid;
break;
case PRECOMPUTED:
kernel_function = &Kernel::kernel_precomputed;
break;
}
clone(x,x_,l);
if(kernel_type == RBF)
{
x_square = new double[l];
for(int i=0;iindex != -1 && py->index != -1)
{
if(px->index == py->index)
{
sum += px->value * py->value;
++px;
++py;
}
else
{
if(px->index > py->index)
++py;
else
++px;
}
}
return sum;
}
double Kernel::k_function(const svm_node *x, const svm_node *y,
const svm_parameter& param)
{
switch(param.kernel_type)
{
case LINEAR:
return dot(x,y);
case POLY:
return powi(param.gamma*dot(x,y)+param.coef0,param.degree);
case RBF:
{
double sum = 0;
while(x->index != -1 && y->index !=-1)
{
if(x->index == y->index)
{
double d = x->value - y->value;
sum += d*d;
++x;
++y;
}
else
{
if(x->index > y->index)
{
sum += y->value * y->value;
++y;
}
else
{
sum += x->value * x->value;
++x;
}
}
}
while(x->index != -1)
{
sum += x->value * x->value;
++x;
}
while(y->index != -1)
{
sum += y->value * y->value;
++y;
}
return exp(-param.gamma*sum);
}
case SIGMOID:
return tanh(param.gamma*dot(x,y)+param.coef0);
case PRECOMPUTED: //x: test (validation), y: SV
return x[(int)(y->value)].value;
default:
return 0; // Unreachable
}
}
// An SMO algorithm in Fan et al., JMLR 6(2005), p. 1889--1918
// Solves:
//
// min 0.5(\alpha^T Q \alpha) + p^T \alpha
//
// y^T \alpha = \delta
// y_i = +1 or -1
// 0 <= alpha_i <= Cp for y_i = 1
// 0 <= alpha_i <= Cn for y_i = -1
//
// Given:
//
// Q, p, y, Cp, Cn, and an initial feasible point \alpha
// l is the size of vectors and matrices
// eps is the stopping tolerance
//
// solution will be put in \alpha, objective value will be put in obj
//
class Solver {
public:
Solver() {};
virtual ~Solver() {};
struct SolutionInfo {
double obj;
double rho;
double upper_bound_p;
double upper_bound_n;
double r; // for Solver_NU
};
void Solve(int l, const QMatrix& Q, const double *p_, const schar *y_,
double *alpha_, double Cp, double Cn, double eps,
SolutionInfo* si, int shrinking);
protected:
int active_size;
schar *y;
double *G; // gradient of objective function
enum { LOWER_BOUND, UPPER_BOUND, FREE };
char *alpha_status; // LOWER_BOUND, UPPER_BOUND, FREE
double *alpha;
const QMatrix *Q;
const Qfloat *QD;
double eps;
double Cp,Cn;
double *p;
int *active_set;
double *G_bar; // gradient, if we treat free variables as 0
int l;
bool unshrink; // XXX
double get_C(int i)
{
return (y[i] > 0)? Cp : Cn;
}
void update_alpha_status(int i)
{
if(alpha[i] >= get_C(i))
alpha_status[i] = UPPER_BOUND;
else if(alpha[i] <= 0)
alpha_status[i] = LOWER_BOUND;
else alpha_status[i] = FREE;
}
bool is_upper_bound(int i) { return alpha_status[i] == UPPER_BOUND; }
bool is_lower_bound(int i) { return alpha_status[i] == LOWER_BOUND; }
bool is_free(int i) { return alpha_status[i] == FREE; }
void swap_index(int i, int j);
void reconstruct_gradient();
virtual int select_working_set(int &i, int &j);
virtual double calculate_rho();
virtual void do_shrinking();
private:
bool be_shrunk(int i, double Gmax1, double Gmax2);
};
void Solver::swap_index(int i, int j)
{
Q->swap_index(i,j);
swap(y[i],y[j]);
swap(G[i],G[j]);
swap(alpha_status[i],alpha_status[j]);
swap(alpha[i],alpha[j]);
swap(p[i],p[j]);
swap(active_set[i],active_set[j]);
swap(G_bar[i],G_bar[j]);
}
void Solver::reconstruct_gradient()
{
// reconstruct inactive elements of G from G_bar and free variables
if(active_size == l) return;
int i,j;
int nr_free = 0;
for(j=active_size;j 2*active_size*(l-active_size))
{
for(i=active_size;iget_Q(i,active_size);
for(j=0;jget_Q(i,l);
double alpha_i = alpha[i];
for(j=active_size;jl = l;
this->Q = &Q;
QD=Q.get_QD();
clone(p, p_,l);
clone(y, y_,l);
clone(alpha,alpha_,l);
this->Cp = Cp;
this->Cn = Cn;
this->eps = eps;
unshrink = false;
// initialize alpha_status
{
alpha_status = new char[l];
for(int i=0;i 0)
{
if(alpha[j] < 0)
{
alpha[j] = 0;
alpha[i] = diff;
}
}
else
{
if(alpha[i] < 0)
{
alpha[i] = 0;
alpha[j] = -diff;
}
}
if(diff > C_i - C_j)
{
if(alpha[i] > C_i)
{
alpha[i] = C_i;
alpha[j] = C_i - diff;
}
}
else
{
if(alpha[j] > C_j)
{
alpha[j] = C_j;
alpha[i] = C_j + diff;
}
}
}
else
{
double quad_coef = Q_i[i]+Q_j[j]-2*Q_i[j];
if (quad_coef <= 0)
quad_coef = TAU;
double delta = (G[i]-G[j])/quad_coef;
double sum = alpha[i] + alpha[j];
alpha[i] -= delta;
alpha[j] += delta;
if(sum > C_i)
{
if(alpha[i] > C_i)
{
alpha[i] = C_i;
alpha[j] = sum - C_i;
}
}
else
{
if(alpha[j] < 0)
{
alpha[j] = 0;
alpha[i] = sum;
}
}
if(sum > C_j)
{
if(alpha[j] > C_j)
{
alpha[j] = C_j;
alpha[i] = sum - C_j;
}
}
else
{
if(alpha[i] < 0)
{
alpha[i] = 0;
alpha[j] = sum;
}
}
}
// update G
double delta_alpha_i = alpha[i] - old_alpha_i;
double delta_alpha_j = alpha[j] - old_alpha_j;
for(int k=0;krho = calculate_rho();
// calculate objective value
{
double v = 0;
int i;
for(i=0;iobj = v/2;
}
// put back the solution
{
for(int i=0;iupper_bound_p = Cp;
si->upper_bound_n = Cn;
info("\noptimization finished, #iter = %d\n",iter);
delete[] p;
delete[] y;
delete[] alpha;
delete[] alpha_status;
delete[] active_set;
delete[] G;
delete[] G_bar;
}
// return 1 if already optimal, return 0 otherwise
int Solver::select_working_set(int &out_i, int &out_j)
{
// return i,j such that
// i: maximizes -y_i * grad(f)_i, i in I_up(\alpha)
// j: minimizes the decrease of obj value
// (if quadratic coefficeint <= 0, replace it with tau)
// -y_j*grad(f)_j < -y_i*grad(f)_i, j in I_low(\alpha)
double Gmax = -INF;
double Gmax2 = -INF;
int Gmax_idx = -1;
int Gmin_idx = -1;
double obj_diff_min = INF;
for(int t=0;t= Gmax)
{
Gmax = -G[t];
Gmax_idx = t;
}
}
else
{
if(!is_lower_bound(t))
if(G[t] >= Gmax)
{
Gmax = G[t];
Gmax_idx = t;
}
}
int i = Gmax_idx;
const Qfloat *Q_i = NULL;
if(i != -1) // NULL Q_i not accessed: Gmax=-INF if i=-1
Q_i = Q->get_Q(i,active_size);
for(int j=0;j= Gmax2)
Gmax2 = G[j];
if (grad_diff > 0)
{
double obj_diff;
double quad_coef=Q_i[i]+QD[j]-2.0*y[i]*Q_i[j];
if (quad_coef > 0)
obj_diff = -(grad_diff*grad_diff)/quad_coef;
else
obj_diff = -(grad_diff*grad_diff)/TAU;
if (obj_diff <= obj_diff_min)
{
Gmin_idx=j;
obj_diff_min = obj_diff;
}
}
}
}
else
{
if (!is_upper_bound(j))
{
double grad_diff= Gmax-G[j];
if (-G[j] >= Gmax2)
Gmax2 = -G[j];
if (grad_diff > 0)
{
double obj_diff;
double quad_coef=Q_i[i]+QD[j]+2.0*y[i]*Q_i[j];
if (quad_coef > 0)
obj_diff = -(grad_diff*grad_diff)/quad_coef;
else
obj_diff = -(grad_diff*grad_diff)/TAU;
if (obj_diff <= obj_diff_min)
{
Gmin_idx=j;
obj_diff_min = obj_diff;
}
}
}
}
}
if(Gmax+Gmax2 < eps)
return 1;
out_i = Gmax_idx;
out_j = Gmin_idx;
return 0;
}
bool Solver::be_shrunk(int i, double Gmax1, double Gmax2)
{
if(is_upper_bound(i))
{
if(y[i]==+1)
return(-G[i] > Gmax1);
else
return(-G[i] > Gmax2);
}
else if(is_lower_bound(i))
{
if(y[i]==+1)
return(G[i] > Gmax2);
else
return(G[i] > Gmax1);
}
else
return(false);
}
void Solver::do_shrinking()
{
int i;
double Gmax1 = -INF; // max { -y_i * grad(f)_i | i in I_up(\alpha) }
double Gmax2 = -INF; // max { y_i * grad(f)_i | i in I_low(\alpha) }
// find maximal violating pair first
for(i=0;i= Gmax1)
Gmax1 = -G[i];
}
if(!is_lower_bound(i))
{
if(G[i] >= Gmax2)
Gmax2 = G[i];
}
}
else
{
if(!is_upper_bound(i))
{
if(-G[i] >= Gmax2)
Gmax2 = -G[i];
}
if(!is_lower_bound(i))
{
if(G[i] >= Gmax1)
Gmax1 = G[i];
}
}
}
if(unshrink == false && Gmax1 + Gmax2 <= eps*10)
{
unshrink = true;
reconstruct_gradient();
active_size = l;
info("*");
}
for(i=0;i i)
{
if (!be_shrunk(active_size, Gmax1, Gmax2))
{
swap_index(i,active_size);
break;
}
active_size--;
}
}
}
double Solver::calculate_rho()
{
double r;
int nr_free = 0;
double ub = INF, lb = -INF, sum_free = 0;
for(int i=0;i0)
r = sum_free/nr_free;
else
r = (ub+lb)/2;
return r;
}
//
// Solver for nu-svm classification and regression
//
// additional constraint: e^T \alpha = constant
//
class Solver_NU : public Solver
{
public:
Solver_NU() {}
void Solve(int l, const QMatrix& Q, const double *p, const schar *y,
double *alpha, double Cp, double Cn, double eps,
SolutionInfo* si, int shrinking)
{
this->si = si;
Solver::Solve(l,Q,p,y,alpha,Cp,Cn,eps,si,shrinking);
}
private:
SolutionInfo *si;
int select_working_set(int &i, int &j);
double calculate_rho();
bool be_shrunk(int i, double Gmax1, double Gmax2, double Gmax3, double Gmax4);
void do_shrinking();
};
// return 1 if already optimal, return 0 otherwise
int Solver_NU::select_working_set(int &out_i, int &out_j)
{
// return i,j such that y_i = y_j and
// i: maximizes -y_i * grad(f)_i, i in I_up(\alpha)
// j: minimizes the decrease of obj value
// (if quadratic coefficeint <= 0, replace it with tau)
// -y_j*grad(f)_j < -y_i*grad(f)_i, j in I_low(\alpha)
double Gmaxp = -INF;
double Gmaxp2 = -INF;
int Gmaxp_idx = -1;
double Gmaxn = -INF;
double Gmaxn2 = -INF;
int Gmaxn_idx = -1;
int Gmin_idx = -1;
double obj_diff_min = INF;
for(int t=0;t= Gmaxp)
{
Gmaxp = -G[t];
Gmaxp_idx = t;
}
}
else
{
if(!is_lower_bound(t))
if(G[t] >= Gmaxn)
{
Gmaxn = G[t];
Gmaxn_idx = t;
}
}
int ip = Gmaxp_idx;
int in = Gmaxn_idx;
const Qfloat *Q_ip = NULL;
const Qfloat *Q_in = NULL;
if(ip != -1) // NULL Q_ip not accessed: Gmaxp=-INF if ip=-1
Q_ip = Q->get_Q(ip,active_size);
if(in != -1)
Q_in = Q->get_Q(in,active_size);
for(int j=0;j= Gmaxp2)
Gmaxp2 = G[j];
if (grad_diff > 0)
{
double obj_diff;
double quad_coef = Q_ip[ip]+QD[j]-2*Q_ip[j];
if (quad_coef > 0)
obj_diff = -(grad_diff*grad_diff)/quad_coef;
else
obj_diff = -(grad_diff*grad_diff)/TAU;
if (obj_diff <= obj_diff_min)
{
Gmin_idx=j;
obj_diff_min = obj_diff;
}
}
}
}
else
{
if (!is_upper_bound(j))
{
double grad_diff=Gmaxn-G[j];
if (-G[j] >= Gmaxn2)
Gmaxn2 = -G[j];
if (grad_diff > 0)
{
double obj_diff;
double quad_coef = Q_in[in]+QD[j]-2*Q_in[j];
if (quad_coef > 0)
obj_diff = -(grad_diff*grad_diff)/quad_coef;
else
obj_diff = -(grad_diff*grad_diff)/TAU;
if (obj_diff <= obj_diff_min)
{
Gmin_idx=j;
obj_diff_min = obj_diff;
}
}
}
}
}
if(max(Gmaxp+Gmaxp2,Gmaxn+Gmaxn2) < eps)
return 1;
if (y[Gmin_idx] == +1)
out_i = Gmaxp_idx;
else
out_i = Gmaxn_idx;
out_j = Gmin_idx;
return 0;
}
bool Solver_NU::be_shrunk(int i, double Gmax1, double Gmax2, double Gmax3, double Gmax4)
{
if(is_upper_bound(i))
{
if(y[i]==+1)
return(-G[i] > Gmax1);
else
return(-G[i] > Gmax4);
}
else if(is_lower_bound(i))
{
if(y[i]==+1)
return(G[i] > Gmax2);
else
return(G[i] > Gmax3);
}
else
return(false);
}
void Solver_NU::do_shrinking()
{
double Gmax1 = -INF; // max { -y_i * grad(f)_i | y_i = +1, i in I_up(\alpha) }
double Gmax2 = -INF; // max { y_i * grad(f)_i | y_i = +1, i in I_low(\alpha) }
double Gmax3 = -INF; // max { -y_i * grad(f)_i | y_i = -1, i in I_up(\alpha) }
double Gmax4 = -INF; // max { y_i * grad(f)_i | y_i = -1, i in I_low(\alpha) }
// find maximal violating pair first
int i;
for(i=0;i Gmax1) Gmax1 = -G[i];
}
else if(-G[i] > Gmax4) Gmax4 = -G[i];
}
if(!is_lower_bound(i))
{
if(y[i]==+1)
{
if(G[i] > Gmax2) Gmax2 = G[i];
}
else if(G[i] > Gmax3) Gmax3 = G[i];
}
}
if(unshrink == false && max(Gmax1+Gmax2,Gmax3+Gmax4) <= eps*10)
{
unshrink = true;
reconstruct_gradient();
active_size = l;
}
for(i=0;i i)
{
if (!be_shrunk(active_size, Gmax1, Gmax2, Gmax3, Gmax4))
{
swap_index(i,active_size);
break;
}
active_size--;
}
}
}
double Solver_NU::calculate_rho()
{
int nr_free1 = 0,nr_free2 = 0;
double ub1 = INF, ub2 = INF;
double lb1 = -INF, lb2 = -INF;
double sum_free1 = 0, sum_free2 = 0;
for(int i=0;i 0)
r1 = sum_free1/nr_free1;
else
r1 = (ub1+lb1)/2;
if(nr_free2 > 0)
r2 = sum_free2/nr_free2;
else
r2 = (ub2+lb2)/2;
si->r = (r1+r2)/2;
return (r1-r2)/2;
}
//
// Q matrices for various formulations
//
class SVC_Q: public Kernel
{
public:
SVC_Q(const svm_problem& prob, const svm_parameter& param, const schar *y_)
:Kernel(prob.l, prob.x, param)
{
clone(y,y_,prob.l);
cache = new Cache(prob.l,(long int)(param.cache_size*(1<<20)));
QD = new Qfloat[prob.l];
for(int i=0;i*kernel_function)(i,i);
}
Qfloat *get_Q(int i, int len) const
{
Qfloat *data;
int start, j;
if((start = cache->get_data(i,&data,len)) < len)
{
for(j=start;j*kernel_function)(i,j));
}
return data;
}
Qfloat *get_QD() const
{
return QD;
}
void swap_index(int i, int j) const
{
cache->swap_index(i,j);
Kernel::swap_index(i,j);
swap(y[i],y[j]);
swap(QD[i],QD[j]);
}
~SVC_Q()
{
delete[] y;
delete cache;
delete[] QD;
}
private:
schar *y;
Cache *cache;
Qfloat *QD;
};
class ONE_CLASS_Q: public Kernel
{
public:
ONE_CLASS_Q(const svm_problem& prob, const svm_parameter& param)
:Kernel(prob.l, prob.x, param)
{
cache = new Cache(prob.l,(long int)(param.cache_size*(1<<20)));
QD = new Qfloat[prob.l];
for(int i=0;i*kernel_function)(i,i);
}
Qfloat *get_Q(int i, int len) const
{
Qfloat *data;
int start, j;
if((start = cache->get_data(i,&data,len)) < len)
{
for(j=start;j*kernel_function)(i,j);
}
return data;
}
Qfloat *get_QD() const
{
return QD;
}
void swap_index(int i, int j) const
{
cache->swap_index(i,j);
Kernel::swap_index(i,j);
swap(QD[i],QD[j]);
}
~ONE_CLASS_Q()
{
delete cache;
delete[] QD;
}
private:
Cache *cache;
Qfloat *QD;
};
class SVR_Q: public Kernel
{
public:
SVR_Q(const svm_problem& prob, const svm_parameter& param)
:Kernel(prob.l, prob.x, param)
{
l = prob.l;
cache = new Cache(l,(long int)(param.cache_size*(1<<20)));
QD = new Qfloat[2*l];
sign = new schar[2*l];
index = new int[2*l];
for(int k=0;k*kernel_function)(k,k);
QD[k+l]=QD[k];
}
buffer[0] = new Qfloat[2*l];
buffer[1] = new Qfloat[2*l];
next_buffer = 0;
}
void swap_index(int i, int j) const
{
swap(sign[i],sign[j]);
swap(index[i],index[j]);
swap(QD[i],QD[j]);
}
Qfloat *get_Q(int i, int len) const
{
Qfloat *data;
int j, real_i = index[i];
if(cache->get_data(real_i,&data,l) < l)
{
for(j=0;j*kernel_function)(real_i,j);
}
// reorder and copy
Qfloat *buf = buffer[next_buffer];
next_buffer = 1 - next_buffer;
schar si = sign[i];
for(j=0;jl;
double *minus_ones = new double[l];
schar *y = new schar[l];
int i;
for(i=0;iy[i] > 0) y[i] = +1; else y[i]=-1;
}
Solver s;
s.Solve(l, SVC_Q(*prob,*param,y), minus_ones, y,
alpha, Cp, Cn, param->eps, si, param->shrinking);
double sum_alpha=0;
for(i=0;il));
for(i=0;il;
double nu = param->nu;
schar *y = new schar[l];
for(i=0;iy[i]>0)
y[i] = +1;
else
y[i] = -1;
double sum_pos = nu*l/2;
double sum_neg = nu*l/2;
for(i=0;ieps, si, param->shrinking);
double r = si->r;
info("C = %f\n",1/r);
for(i=0;irho /= r;
si->obj /= (r*r);
si->upper_bound_p = 1/r;
si->upper_bound_n = 1/r;
delete[] y;
delete[] zeros;
}
static void solve_one_class(
const svm_problem *prob, const svm_parameter *param,
double *alpha, Solver::SolutionInfo* si)
{
int l = prob->l;
double *zeros = new double[l];
schar *ones = new schar[l];
int i;
int n = (int)(param->nu*prob->l); // # of alpha's at upper bound
for(i=0;il)
alpha[n] = param->nu * prob->l - n;
for(i=n+1;ieps, si, param->shrinking);
delete[] zeros;
delete[] ones;
}
static void solve_epsilon_svr(
const svm_problem *prob, const svm_parameter *param,
double *alpha, Solver::SolutionInfo* si)
{
int l = prob->l;
double *alpha2 = new double[2*l];
double *linear_term = new double[2*l];
schar *y = new schar[2*l];
int i;
for(i=0;ip - prob->y[i];
y[i] = 1;
alpha2[i+l] = 0;
linear_term[i+l] = param->p + prob->y[i];
y[i+l] = -1;
}
Solver s;
s.Solve(2*l, SVR_Q(*prob,*param), linear_term, y,
alpha2, param->C, param->C, param->eps, si, param->shrinking);
double sum_alpha = 0;
for(i=0;iC*l));
delete[] alpha2;
delete[] linear_term;
delete[] y;
}
static void solve_nu_svr(
const svm_problem *prob, const svm_parameter *param,
double *alpha, Solver::SolutionInfo* si)
{
int l = prob->l;
double C = param->C;
double *alpha2 = new double[2*l];
double *linear_term = new double[2*l];
schar *y = new schar[2*l];
int i;
double sum = C * param->nu * l / 2;
for(i=0;iy[i];
y[i] = 1;
linear_term[i+l] = prob->y[i];
y[i+l] = -1;
}
Solver_NU s;
s.Solve(2*l, SVR_Q(*prob,*param), linear_term, y,
alpha2, C, C, param->eps, si, param->shrinking);
info("epsilon = %f\n",-si->r);
for(i=0;il);
Solver::SolutionInfo si;
switch(param->svm_type)
{
case C_SVC:
solve_c_svc(prob,param,alpha,&si,Cp,Cn);
break;
case NU_SVC:
solve_nu_svc(prob,param,alpha,&si);
break;
case ONE_CLASS:
solve_one_class(prob,param,alpha,&si);
break;
case EPSILON_SVR:
solve_epsilon_svr(prob,param,alpha,&si);
break;
case NU_SVR:
solve_nu_svr(prob,param,alpha,&si);
break;
}
info("obj = %f, rho = %f\n",si.obj,si.rho);
// output SVs
int nSV = 0;
int nBSV = 0;
for(int i=0;il;i++)
{
if(fabs(alpha[i]) > 0)
{
++nSV;
if(prob->y[i] > 0)
{
if(fabs(alpha[i]) >= si.upper_bound_p)
++nBSV;
}
else
{
if(fabs(alpha[i]) >= si.upper_bound_n)
++nBSV;
}
}
}
info("nSV = %d, nBSV = %d\n",nSV,nBSV);
decision_function f;
f.alpha = alpha;
f.rho = si.rho;
return f;
}
//
// svm_model
//
struct svm_model
{
svm_parameter param; // parameter
int nr_class; // number of classes, = 2 in regression/one class svm
int l; // total #SV
svm_node **SV; // SVs (SV[l])
double **sv_coef; // coefficients for SVs in decision functions (sv_coef[k-1][l])
double *rho; // constants in decision functions (rho[k*(k-1)/2])
double *probA; // pariwise probability information
double *probB;
// for classification only
int *label; // label of each class (label[k])
int *nSV; // number of SVs for each class (nSV[k])
// nSV[0] + nSV[1] + ... + nSV[k-1] = l
// XXX
int free_sv; // 1 if svm_model is created by svm_load_model
// 0 if svm_model is created by svm_train
};
// Platt's binary SVM Probablistic Output: an improvement from Lin et al.
void sigmoid_train(
int l, const double *dec_values, const double *labels,
double& A, double& B)
{
double prior1=0, prior0 = 0;
int i;
for (i=0;i 0) prior1+=1;
else prior0+=1;
int max_iter=100; // Maximal number of iterations
double min_step=1e-10; // Minimal step taken in line search
double sigma=1e-12; // For numerically strict PD of Hessian
double eps=1e-5;
double hiTarget=(prior1+1.0)/(prior1+2.0);
double loTarget=1/(prior0+2.0);
double *t=Malloc(double,l);
double fApB,p,q,h11,h22,h21,g1,g2,det,dA,dB,gd,stepsize;
double newA,newB,newf,d1,d2;
int iter;
// Initial Point and Initial Fun Value
A=0.0; B=log((prior0+1.0)/(prior1+1.0));
double fval = 0.0;
for (i=0;i0) t[i]=hiTarget;
else t[i]=loTarget;
fApB = dec_values[i]*A+B;
if (fApB>=0)
fval += t[i]*fApB + log(1+exp(-fApB));
else
fval += (t[i] - 1)*fApB +log(1+exp(fApB));
}
for (iter=0;iter= 0)
{
p=exp(-fApB)/(1.0+exp(-fApB));
q=1.0/(1.0+exp(-fApB));
}
else
{
p=1.0/(1.0+exp(fApB));
q=exp(fApB)/(1.0+exp(fApB));
}
d2=p*q;
h11+=dec_values[i]*dec_values[i]*d2;
h22+=d2;
h21+=dec_values[i]*d2;
d1=t[i]-p;
g1+=dec_values[i]*d1;
g2+=d1;
}
// Stopping Criteria
if (fabs(g1)= min_step)
{
newA = A + stepsize * dA;
newB = B + stepsize * dB;
// New function value
newf = 0.0;
for (i=0;i= 0)
newf += t[i]*fApB + log(1+exp(-fApB));
else
newf += (t[i] - 1)*fApB +log(1+exp(fApB));
}
// Check sufficient decrease
if (newf=max_iter)
info("Reaching maximal iterations in two-class probability estimates\n");
free(t);
}
double sigmoid_predict(double decision_value, double A, double B)
{
double fApB = decision_value*A+B;
if (fApB >= 0)
return exp(-fApB)/(1.0+exp(-fApB));
else
return 1.0/(1+exp(fApB)) ;
}
// Method 2 from the multiclass_prob paper by Wu, Lin, and Weng
void multiclass_probability(int k, double **r, double *p)
{
int t,j;
int iter = 0, max_iter=max(100,k);
double **Q=Malloc(double *,k);
double *Qp=Malloc(double,k);
double pQp, eps=0.005/k;
for (t=0;tmax_error)
max_error=error;
}
if (max_error=max_iter)
info("Exceeds max_iter in multiclass_prob\n");
for(t=0;tl);
double *dec_values = Malloc(double,prob->l);
// random shuffle
for(i=0;il;i++) perm[i]=i;
for(i=0;il;i++)
{
int j = i+rand()%(prob->l-i);
swap(perm[i],perm[j]);
}
for(i=0;il/nr_fold;
int end = (i+1)*prob->l/nr_fold;
int j,k;
struct svm_problem subprob;
subprob.l = prob->l-(end-begin);
subprob.x = Malloc(struct svm_node*,subprob.l);
subprob.y = Malloc(double,subprob.l);
k=0;
for(j=0;jx[perm[j]];
subprob.y[k] = prob->y[perm[j]];
++k;
}
for(j=end;jl;j++)
{
subprob.x[k] = prob->x[perm[j]];
subprob.y[k] = prob->y[perm[j]];
++k;
}
int p_count=0,n_count=0;
for(j=0;j0)
p_count++;
else
n_count++;
if(p_count==0 && n_count==0)
for(j=begin;j 0 && n_count == 0)
for(j=begin;j 0)
for(j=begin;jx[perm[j]],&(dec_values[perm[j]]));
// ensure +1 -1 order; reason not using CV subroutine
dec_values[perm[j]] *= submodel->label[0];
}
svm_destroy_model(submodel);
svm_destroy_param(&subparam);
}
free(subprob.x);
free(subprob.y);
}
sigmoid_train(prob->l,dec_values,prob->y,probA,probB);
free(dec_values);
free(perm);
}
// Return parameter of a Laplace distribution
double svm_svr_probability(
const svm_problem *prob, const svm_parameter *param)
{
int i;
int nr_fold = 5;
double *ymv = Malloc(double,prob->l);
double mae = 0;
svm_parameter newparam = *param;
newparam.probability = 0;
svm_cross_validation(prob,&newparam,nr_fold,ymv);
for(i=0;il;i++)
{
ymv[i]=prob->y[i]-ymv[i];
mae += fabs(ymv[i]);
}
mae /= prob->l;
double std=sqrt(2*mae*mae);
int count=0;
mae=0;
for(i=0;il;i++)
if (fabs(ymv[i]) > 5*std)
count=count+1;
else
mae+=fabs(ymv[i]);
mae /= (prob->l-count);
info("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma= %g\n",mae);
free(ymv);
return mae;
}
// label: label name, start: begin of each class, count: #data of classes, perm: indices to the original data
// perm, length l, must be allocated before calling this subroutine
void svm_group_classes(const svm_problem *prob, int *nr_class_ret, int **label_ret, int **start_ret, int **count_ret, int *perm)
{
int l = prob->l;
int max_nr_class = 16;
int nr_class = 0;
int *label = Malloc(int,max_nr_class);
int *count = Malloc(int,max_nr_class);
int *data_label = Malloc(int,l);
int i;
for(i=0;iy[i];
int j;
for(j=0;jparam = *param;
model->free_sv = 0; // XXX
if(param->svm_type == ONE_CLASS ||
param->svm_type == EPSILON_SVR ||
param->svm_type == NU_SVR)
{
// regression or one-class-svm
model->nr_class = 2;
model->label = NULL;
model->nSV = NULL;
model->probA = NULL; model->probB = NULL;
model->sv_coef = Malloc(double *,1);
if(param->probability &&
(param->svm_type == EPSILON_SVR ||
param->svm_type == NU_SVR))
{
model->probA = Malloc(double,1);
model->probA[0] = svm_svr_probability(prob,param);
}
decision_function f = svm_train_one(prob,param,0,0);
model->rho = Malloc(double,1);
model->rho[0] = f.rho;
int nSV = 0;
int i;
for(i=0;il;i++)
if(fabs(f.alpha[i]) > 0) ++nSV;
model->l = nSV;
model->SV = Malloc(svm_node *,nSV);
model->sv_coef[0] = Malloc(double,nSV);
int j = 0;
for(i=0;il;i++)
if(fabs(f.alpha[i]) > 0)
{
model->SV[j] = prob->x[i];
model->sv_coef[0][j] = f.alpha[i];
++j;
}
free(f.alpha);
}
else
{
// classification
int l = prob->l;
int nr_class;
int *label = NULL;
int *start = NULL;
int *count = NULL;
int *perm = Malloc(int,l);
// group training data of the same class
svm_group_classes(prob,&nr_class,&label,&start,&count,perm);
svm_node **x = Malloc(svm_node *,l);
int i;
for(i=0;ix[perm[i]];
// calculate weighted C
double *weighted_C = Malloc(double, nr_class);
for(i=0;iC;
for(i=0;inr_weight;i++)
{
int j;
for(j=0;jweight_label[i] == label[j])
break;
if(j == nr_class)
fprintf(stderr,"warning: class label %d specified in weight is not found\n", param->weight_label[i]);
else
weighted_C[j] *= param->weight[i];
}
// train k*(k-1)/2 models
bool *nonzero = Malloc(bool,l);
for(i=0;iprobability)
{
probA=Malloc(double,nr_class*(nr_class-1)/2);
probB=Malloc(double,nr_class*(nr_class-1)/2);
}
int p = 0;
for(i=0;iprobability)
svm_binary_svc_probability(&sub_prob,param,weighted_C[i],weighted_C[j],probA[p],probB[p]);
f[p] = svm_train_one(&sub_prob,param,weighted_C[i],weighted_C[j]);
for(k=0;k 0)
nonzero[si+k] = true;
for(k=0;k 0)
nonzero[sj+k] = true;
free(sub_prob.x);
free(sub_prob.y);
++p;
}
// build output
model->nr_class = nr_class;
model->label = Malloc(int,nr_class);
for(i=0;ilabel[i] = label[i];
model->rho = Malloc(double,nr_class*(nr_class-1)/2);
for(i=0;irho[i] = f[i].rho;
if(param->probability)
{
model->probA = Malloc(double,nr_class*(nr_class-1)/2);
model->probB = Malloc(double,nr_class*(nr_class-1)/2);
for(i=0;iprobA[i] = probA[i];
model->probB[i] = probB[i];
}
}
else
{
model->probA=NULL;
model->probB=NULL;
}
int total_sv = 0;
int *nz_count = Malloc(int,nr_class);
model->nSV = Malloc(int,nr_class);
for(i=0;inSV[i] = nSV;
nz_count[i] = nSV;
}
info("Total nSV = %d\n",total_sv);
model->l = total_sv;
model->SV = Malloc(svm_node *,total_sv);
p = 0;
for(i=0;iSV[p++] = x[i];
int *nz_start = Malloc(int,nr_class);
nz_start[0] = 0;
for(i=1;isv_coef = Malloc(double *,nr_class-1);
for(i=0;isv_coef[i] = Malloc(double,total_sv);
p = 0;
for(i=0;isv_coef[j-1][q++] = f[p].alpha[k];
q = nz_start[j];
for(k=0;ksv_coef[i][q++] = f[p].alpha[ci+k];
++p;
}
free(label);
free(probA);
free(probB);
free(count);
free(perm);
free(start);
free(x);
free(weighted_C);
free(nonzero);
for(i=0;il;
int *perm = Malloc(int,l);
int nr_class;
// stratified cv may not give leave-one-out rate
// Each class to l folds -> some folds may have zero elements
if((param->svm_type == C_SVC ||
param->svm_type == NU_SVC) && nr_fold < l)
{
int *start = NULL;
int *label = NULL;
int *count = NULL;
svm_group_classes(prob,&nr_class,&label,&start,&count,perm);
// random shuffle and then data grouped by fold using the array perm
int *fold_count = Malloc(int,nr_fold);
int c;
int *index = Malloc(int,l);
for(i=0;ix[perm[j]];
subprob.y[k] = prob->y[perm[j]];
++k;
}
for(j=end;jx[perm[j]];
subprob.y[k] = prob->y[perm[j]];
++k;
}
struct svm_model *submodel = svm_train(&subprob,param);
if(param->probability &&
(param->svm_type == C_SVC || param->svm_type == NU_SVC))
{
double *prob_estimates=Malloc(double,svm_get_nr_class(submodel));
for(j=begin;jx[perm[j]],prob_estimates);
free(prob_estimates);
}
else
for(j=begin;jx[perm[j]]);
svm_destroy_model(submodel);
free(subprob.x);
free(subprob.y);
}
free(fold_start);
free(perm);
}
int svm_get_svm_type(const svm_model *model)
{
return model->param.svm_type;
}
int svm_get_nr_class(const svm_model *model)
{
return model->nr_class;
}
void svm_get_labels(const svm_model *model, int* label)
{
if (model->label != NULL)
for(int i=0;inr_class;i++)
label[i] = model->label[i];
}
double svm_get_svr_probability(const svm_model *model)
{
if ((model->param.svm_type == EPSILON_SVR || model->param.svm_type == NU_SVR) &&
model->probA!=NULL)
return model->probA[0];
else
{
fprintf(stderr,"Model doesn't contain information for SVR probability inference\n");
return 0;
}
}
void svm_predict_values(const svm_model *model, const svm_node *x, double* dec_values)
{
if(model->param.svm_type == ONE_CLASS ||
model->param.svm_type == EPSILON_SVR ||
model->param.svm_type == NU_SVR)
{
double *sv_coef = model->sv_coef[0];
double sum = 0;
for(int i=0;il;i++)
sum += sv_coef[i] * Kernel::k_function(x,model->SV[i],model->param);
sum -= model->rho[0];
*dec_values = sum;
}
else
{
int i;
int nr_class = model->nr_class;
int l = model->l;
double *kvalue = Malloc(double,l);
for(i=0;iSV[i],model->param);
int *start = Malloc(int,nr_class);
start[0] = 0;
for(i=1;inSV[i-1];
int p=0;
for(i=0;inSV[i];
int cj = model->nSV[j];
int k;
double *coef1 = model->sv_coef[j-1];
double *coef2 = model->sv_coef[i];
for(k=0;krho[p];
dec_values[p] = sum;
p++;
}
free(kvalue);
free(start);
}
}
double svm_predict(const svm_model *model, const svm_node *x)
{
if(model->param.svm_type == ONE_CLASS ||
model->param.svm_type == EPSILON_SVR ||
model->param.svm_type == NU_SVR)
{
double res;
svm_predict_values(model, x, &res);
if(model->param.svm_type == ONE_CLASS)
return (res>0)?1:-1;
else
return res;
}
else
{
int i;
int nr_class = model->nr_class;
double *dec_values = Malloc(double, nr_class*(nr_class-1)/2);
svm_predict_values(model, x, dec_values);
int *vote = Malloc(int,nr_class);
for(i=0;i 0)
++vote[i];
else
++vote[j];
}
int vote_max_idx = 0;
for(i=1;i vote[vote_max_idx])
vote_max_idx = i;
free(vote);
free(dec_values);
return model->label[vote_max_idx];
}
}
double svm_predict_probability(
const svm_model *model, const svm_node *x, double *prob_estimates)
{
if ((model->param.svm_type == C_SVC || model->param.svm_type == NU_SVC) &&
model->probA!=NULL && model->probB!=NULL)
{
int i;
int nr_class = model->nr_class;
double *dec_values = Malloc(double, nr_class*(nr_class-1)/2);
svm_predict_values(model, x, dec_values);
double min_prob=1e-7;
double **pairwise_prob=Malloc(double *,nr_class);
for(i=0;iprobA[k],model->probB[k]),min_prob),1-min_prob);
pairwise_prob[j][i]=1-pairwise_prob[i][j];
k++;
}
multiclass_probability(nr_class,pairwise_prob,prob_estimates);
int prob_max_idx = 0;
for(i=1;i prob_estimates[prob_max_idx])
prob_max_idx = i;
for(i=0;ilabel[prob_max_idx];
}
else
return svm_predict(model, x);
}
const char *svm_type_table[] =
{
"c_svc","nu_svc","one_class","epsilon_svr","nu_svr",NULL
};
const char *kernel_type_table[]=
{
"linear","polynomial","rbf","sigmoid","precomputed",NULL
};
int svm_save_model(const char *model_file_name, const svm_model *model)
{
FILE *fp = fopen(model_file_name,"w");
if(fp==NULL) return -1;
const svm_parameter& param = model->param;
fprintf(fp,"svm_type %s\n", svm_type_table[param.svm_type]);
fprintf(fp,"kernel_type %s\n", kernel_type_table[param.kernel_type]);
if(param.kernel_type == POLY)
fprintf(fp,"degree %d\n", param.degree);
if(param.kernel_type == POLY || param.kernel_type == RBF || param.kernel_type == SIGMOID)
fprintf(fp,"gamma %g\n", param.gamma);
if(param.kernel_type == POLY || param.kernel_type == SIGMOID)
fprintf(fp,"coef0 %g\n", param.coef0);
int nr_class = model->nr_class;
int l = model->l;
fprintf(fp, "nr_class %d\n", nr_class);
fprintf(fp, "total_sv %d\n",l);
{
fprintf(fp, "rho");
for(int i=0;irho[i]);
fprintf(fp, "\n");
}
if(model->label)
{
fprintf(fp, "label");
for(int i=0;ilabel[i]);
fprintf(fp, "\n");
}
if(model->probA) // regression has probA only
{
fprintf(fp, "probA");
for(int i=0;iprobA[i]);
fprintf(fp, "\n");
}
if(model->probB)
{
fprintf(fp, "probB");
for(int i=0;iprobB[i]);
fprintf(fp, "\n");
}
if(model->nSV)
{
fprintf(fp, "nr_sv");
for(int i=0;inSV[i]);
fprintf(fp, "\n");
}
fprintf(fp, "SV\n");
const double * const *sv_coef = model->sv_coef;
const svm_node * const *SV = model->SV;
for(int i=0;ivalue));
else
while(p->index != -1)
{
fprintf(fp,"%d:%.8g ",p->index,p->value);
p++;
}
fprintf(fp, "\n");
}
if (ferror(fp) != 0 || fclose(fp) != 0) return -1;
else return 0;
}
static char *line = NULL;
static int max_line_len;
static char* readline(FILE *input)
{
int len;
if(fgets(line,max_line_len,input) == NULL)
return NULL;
while(strrchr(line,'\n') == NULL)
{
max_line_len *= 2;
line = (char *) realloc(line,max_line_len);
len = (int) strlen(line);
if(fgets(line+len,max_line_len-len,input) == NULL)
break;
}
return line;
}
svm_model *svm_load_model(const char *model_file_name)
{
FILE *fp = fopen(model_file_name,"rb");
if(fp==NULL) return NULL;
// read parameters
svm_model *model = Malloc(svm_model,1);
svm_parameter& param = model->param;
model->rho = NULL;
model->probA = NULL;
model->probB = NULL;
model->label = NULL;
model->nSV = NULL;
char cmd[81];
while(1)
{
fscanf(fp,"%80s",cmd);
if(strcmp(cmd,"svm_type")==0)
{
fscanf(fp,"%80s",cmd);
int i;
for(i=0;svm_type_table[i];i++)
{
if(strcmp(svm_type_table[i],cmd)==0)
{
param.svm_type=i;
break;
}
}
if(svm_type_table[i] == NULL)
{
fprintf(stderr,"unknown svm type.\n");
free(model->rho);
free(model->label);
free(model->nSV);
free(model);
return NULL;
}
}
else if(strcmp(cmd,"kernel_type")==0)
{
fscanf(fp,"%80s",cmd);
int i;
for(i=0;kernel_type_table[i];i++)
{
if(strcmp(kernel_type_table[i],cmd)==0)
{
param.kernel_type=i;
break;
}
}
if(kernel_type_table[i] == NULL)
{
fprintf(stderr,"unknown kernel function.\n");
free(model->rho);
free(model->label);
free(model->nSV);
free(model);
return NULL;
}
}
else if(strcmp(cmd,"degree")==0)
fscanf(fp,"%d",¶m.degree);
else if(strcmp(cmd,"gamma")==0)
fscanf(fp,"%lf",¶m.gamma);
else if(strcmp(cmd,"coef0")==0)
fscanf(fp,"%lf",¶m.coef0);
else if(strcmp(cmd,"nr_class")==0)
fscanf(fp,"%d",&model->nr_class);
else if(strcmp(cmd,"total_sv")==0)
fscanf(fp,"%d",&model->l);
else if(strcmp(cmd,"rho")==0)
{
int n = model->nr_class * (model->nr_class-1)/2;
model->rho = Malloc(double,n);
for(int i=0;irho[i]);
}
else if(strcmp(cmd,"label")==0)
{
int n = model->nr_class;
model->label = Malloc(int,n);
for(int i=0;ilabel[i]);
}
else if(strcmp(cmd,"probA")==0)
{
int n = model->nr_class * (model->nr_class-1)/2;
model->probA = Malloc(double,n);
for(int i=0;iprobA[i]);
}
else if(strcmp(cmd,"probB")==0)
{
int n = model->nr_class * (model->nr_class-1)/2;
model->probB = Malloc(double,n);
for(int i=0;iprobB[i]);
}
else if(strcmp(cmd,"nr_sv")==0)
{
int n = model->nr_class;
model->nSV = Malloc(int,n);
for(int i=0;inSV[i]);
}
else if(strcmp(cmd,"SV")==0)
{
while(1)
{
int c = getc(fp);
if(c==EOF || c=='\n') break;
}
break;
}
else
{
fprintf(stderr,"unknown text in model file: [%s]\n",cmd);
free(model->rho);
free(model->label);
free(model->nSV);
free(model);
return NULL;
}
}
// read sv_coef and SV
int elements = 0;
long pos = ftell(fp);
max_line_len = 1024;
line = Malloc(char,max_line_len);
char *p,*endptr,*idx,*val;
while(readline(fp)!=NULL)
{
p = strtok(line,":");
while(1)
{
p = strtok(NULL,":");
if(p == NULL)
break;
++elements;
}
}
elements += model->l;
fseek(fp,pos,SEEK_SET);
int m = model->nr_class - 1;
int l = model->l;
model->sv_coef = Malloc(double *,m);
int i;
for(i=0;isv_coef[i] = Malloc(double,l);
model->SV = Malloc(svm_node*,l);
svm_node *x_space = NULL;
if(l>0) x_space = Malloc(svm_node,elements);
int j=0;
for(i=0;iSV[i] = &x_space[j];
p = strtok(line, " \t");
model->sv_coef[0][i] = strtod(p,&endptr);
for(int k=1;ksv_coef[k][i] = strtod(p,&endptr);
}
while(1)
{
idx = strtok(NULL, ":");
val = strtok(NULL, " \t");
if(val == NULL)
break;
x_space[j].index = (int) strtol(idx,&endptr,10);
x_space[j].value = strtod(val,&endptr);
++j;
}
x_space[j++].index = -1;
}
free(line);
if (ferror(fp) != 0 || fclose(fp) != 0)
return NULL;
model->free_sv = 1; // XXX
return model;
}
void svm_destroy_model(svm_model* model)
{
if(model->free_sv && model->l > 0)
free((void *)(model->SV[0]));
for(int i=0;inr_class-1;i++)
free(model->sv_coef[i]);
free(model->SV);
free(model->sv_coef);
free(model->rho);
free(model->label);
free(model->probA);
free(model->probB);
free(model->nSV);
free(model);
}
void svm_destroy_param(svm_parameter* param)
{
free(param->weight_label);
free(param->weight);
}
const char *svm_check_parameter(const svm_problem *prob, const svm_parameter *param)
{
// svm_type
int svm_type = param->svm_type;
if(svm_type != C_SVC &&
svm_type != NU_SVC &&
svm_type != ONE_CLASS &&
svm_type != EPSILON_SVR &&
svm_type != NU_SVR)
return "unknown svm type";
// kernel_type, degree
int kernel_type = param->kernel_type;
if(kernel_type != LINEAR &&
kernel_type != POLY &&
kernel_type != RBF &&
kernel_type != SIGMOID &&
kernel_type != PRECOMPUTED)
return "unknown kernel type";
if(param->degree < 0)
return "degree of polynomial kernel < 0";
// cache_size,eps,C,nu,p,shrinking
if(param->cache_size <= 0)
return "cache_size <= 0";
if(param->eps <= 0)
return "eps <= 0";
if(svm_type == C_SVC ||
svm_type == EPSILON_SVR ||
svm_type == NU_SVR)
if(param->C <= 0)
return "C <= 0";
if(svm_type == NU_SVC ||
svm_type == ONE_CLASS ||
svm_type == NU_SVR)
if(param->nu <= 0 || param->nu > 1)
return "nu <= 0 or nu > 1";
if(svm_type == EPSILON_SVR)
if(param->p < 0)
return "p < 0";
if(param->shrinking != 0 &&
param->shrinking != 1)
return "shrinking != 0 and shrinking != 1";
if(param->probability != 0 &&
param->probability != 1)
return "probability != 0 and probability != 1";
if(param->probability == 1 &&
svm_type == ONE_CLASS)
return "one-class SVM probability output not supported yet";
// check whether nu-svc is feasible
if(svm_type == NU_SVC)
{
int l = prob->l;
int max_nr_class = 16;
int nr_class = 0;
int *label = Malloc(int,max_nr_class);
int *count = Malloc(int,max_nr_class);
int i;
for(i=0;iy[i];
int j;
for(j=0;jnu*(n1+n2)/2 > min(n1,n2))
{
free(label);
free(count);
return "specified nu is infeasible";
}
}
}
free(label);
free(count);
}
return NULL;
}
int svm_check_probability_model(const svm_model *model)
{
return ((model->param.svm_type == C_SVC || model->param.svm_type == NU_SVC) &&
model->probA!=NULL && model->probB!=NULL) ||
((model->param.svm_type == EPSILON_SVR || model->param.svm_type == NU_SVR) &&
model->probA!=NULL);
}
opensmile-2.3.0/scripts/modeltrain/libsvm-small/COPYRIGHT 0000660 0002002 0200001 00000002731 13004722023 021776 0 ustar fe audcore
Copyright (c) 2000-2009 Chih-Chung Chang and Chih-Jen Lin
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither name of copyright holders nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
opensmile-2.3.0/scripts/modeltrain/libsvm-small/svm-scale.c 0000660 0002002 0200001 00000015602 13004722023 022542 0 ustar fe audcore #include
#include
#include
#include
#include
void exit_with_help()
{
printf(
"Usage: svm-scale [options] data_filename\n"
"options:\n"
"-l lower : x scaling lower limit (default -1)\n"
"-u upper : x scaling upper limit (default +1)\n"
"-y y_lower y_upper : y scaling limits (default: no y scaling)\n"
"-s save_filename : save scaling parameters to save_filename\n"
"-r restore_filename : restore scaling parameters from restore_filename\n"
);
exit(1);
}
char *line = NULL;
int max_line_len = 1024;
double lower=-1.0,upper=1.0,y_lower,y_upper;
int y_scaling = 0;
double *feature_max;
double *feature_min;
double y_max = -DBL_MAX;
double y_min = DBL_MAX;
int max_index;
long int num_nonzeros = 0;
long int new_num_nonzeros = 0;
#define max(x,y) (((x)>(y))?(x):(y))
#define min(x,y) (((x)<(y))?(x):(y))
void output_target(double value);
void output(int index, double value);
char* readline(FILE *input);
int main(int argc,char **argv)
{
int i,index;
FILE *fp, *fp_restore = NULL;
char *save_filename = NULL;
char *restore_filename = NULL;
for(i=1;i lower) || (y_scaling && !(y_upper > y_lower)))
{
fprintf(stderr,"inconsistent lower/upper specification\n");
exit(1);
}
if(restore_filename && save_filename)
{
fprintf(stderr,"cannot use -r and -s simultaneously\n");
exit(1);
}
if(argc != i+1)
exit_with_help();
fp=fopen(argv[i],"r");
if(fp==NULL)
{
fprintf(stderr,"can't open file %s\n", argv[i]);
exit(1);
}
line = (char *) malloc(max_line_len*sizeof(char));
#define SKIP_TARGET\
while(isspace(*p)) ++p;\
while(!isspace(*p)) ++p;
#define SKIP_ELEMENT\
while(*p!=':') ++p;\
++p;\
while(isspace(*p)) ++p;\
while(*p && !isspace(*p)) ++p;
/* assumption: min index of attributes is 1 */
/* pass 1: find out max index of attributes */
max_index = 0;
if(restore_filename)
{
int idx, c;
fp_restore = fopen(restore_filename,"r");
if(fp_restore==NULL)
{
fprintf(stderr,"can't open file %s\n", restore_filename);
exit(1);
}
c = fgetc(fp_restore);
if(c == 'y')
{
readline(fp_restore);
readline(fp_restore);
readline(fp_restore);
}
readline(fp_restore);
readline(fp_restore);
while(fscanf(fp_restore,"%d %*f %*f\n",&idx) == 1)
max_index = max(idx,max_index);
rewind(fp_restore);
}
while(readline(fp)!=NULL)
{
char *p=line;
SKIP_TARGET
while(sscanf(p,"%d:%*f",&index)==1)
{
max_index = max(max_index, index);
SKIP_ELEMENT
num_nonzeros++;
}
}
rewind(fp);
feature_max = (double *)malloc((max_index+1)* sizeof(double));
feature_min = (double *)malloc((max_index+1)* sizeof(double));
if(feature_max == NULL || feature_min == NULL)
{
fprintf(stderr,"can't allocate enough memory\n");
exit(1);
}
for(i=0;i<=max_index;i++)
{
feature_max[i]=-DBL_MAX;
feature_min[i]=DBL_MAX;
}
/* pass 2: find out min/max value */
while(readline(fp)!=NULL)
{
char *p=line;
int next_index=1;
double target;
double value;
sscanf(p,"%lf",&target);
y_max = max(y_max,target);
y_min = min(y_min,target);
SKIP_TARGET
while(sscanf(p,"%d:%lf",&index,&value)==2)
{
for(i=next_index;i num_nonzeros)
fprintf(stderr,
"Warning: original #nonzeros %ld\n"
" new #nonzeros %ld\n"
"Use -l 0 if many original feature values are zeros\n",
num_nonzeros, new_num_nonzeros);
free(line);
free(feature_max);
free(feature_min);
fclose(fp);
return 0;
}
char* readline(FILE *input)
{
int len;
if(fgets(line,max_line_len,input) == NULL)
return NULL;
while(strrchr(line,'\n') == NULL)
{
max_line_len *= 2;
line = (char *) realloc(line, max_line_len);
len = (int) strlen(line);
if(fgets(line+len,max_line_len-len,input) == NULL)
break;
}
return line;
}
void output_target(double value)
{
if(y_scaling)
{
if(value == y_min)
value = y_lower;
else if(value == y_max)
value = y_upper;
else value = y_lower + (y_upper-y_lower) *
(value - y_min)/(y_max-y_min);
}
printf("%g ",value);
}
void output(int index, double value)
{
/* skip single-valued attribute */
if(feature_max[index] == feature_min[index])
return;
if(value == feature_min[index])
value = lower;
else if(value == feature_max[index])
value = upper;
else
value = lower + (upper-lower) *
(value-feature_min[index])/
(feature_max[index]-feature_min[index]);
if(value != 0)
{
printf("%d:%g ",index, value);
new_num_nonzeros++;
}
}
opensmile-2.3.0/scripts/modeltrain/libsvm-small/Makefile.win 0000660 0002002 0200001 00000002430 13004722023 022733 0 ustar fe audcore #You must ensure nmake.exe, cl.exe, link.exe are in system path.
#VCVARS32.bat
#Under dosbox prompt
#nmake -f Makefile.win
PYTHON_INC = c:\python26\include
PYTHON_LIB = c:\python26\libs\python26.lib
##########################################
CXX = cl.exe
CFLAGS = -nologo -O2 -EHsc -I. -D __WIN32__ -D _CRT_SECURE_NO_DEPRECATE
TARGET = windows
all: $(TARGET)\svm-train.exe $(TARGET)\svm-predict.exe $(TARGET)\svm-scale.exe $(TARGET)\svm-toy.exe
python: $(TARGET)\python\svmc.pyd
$(TARGET)\svm-predict.exe: svm.h svm-predict.c svm.obj
$(CXX) $(CFLAGS) svm-predict.c svm.obj -Fe$(TARGET)\svm-predict.exe
$(TARGET)\svm-train.exe: svm.h svm-train.c svm.obj
$(CXX) $(CFLAGS) svm-train.c svm.obj -Fe$(TARGET)\svm-train.exe
$(TARGET)\svm-scale.exe: svm.h svm-scale.c
$(CXX) $(CFLAGS) svm-scale.c -Fe$(TARGET)\svm-scale.exe
$(TARGET)\svm-toy.exe: svm.h svm.obj svm-toy\windows\svm-toy.cpp
$(CXX) $(CFLAGS) svm-toy\windows\svm-toy.cpp svm.obj user32.lib gdi32.lib comdlg32.lib -Fe$(TARGET)\svm-toy.exe
svm.obj: svm.cpp svm.h
$(CXX) $(CFLAGS) -c svm.cpp
$(TARGET)\python\svmc.pyd: python\svmc_wrap.c svm.obj $(PYTHON_LIB)
$(CXX) $(CFLAGS) -I$(PYTHON_INC) -LD $** -Fe$(TARGET)\python\svmc.pyd
# $** means all dependencies
clean:
-erase /Q *.obj $(TARGET)\. $(TARGET)\python\.
opensmile-2.3.0/scripts/modeltrain/libsvm-small/README 0000660 0002002 0200001 00000054364 13004722023 021374 0 ustar fe audcore Libsvm is a simple, easy-to-use, and efficient software for SVM
classification and regression. It solves C-SVM classification, nu-SVM
classification, one-class-SVM, epsilon-SVM regression, and nu-SVM
regression. It also provides an automatic model selection tool for
C-SVM classification. This document explains the use of libsvm.
Libsvm is available at
http://www.csie.ntu.edu.tw/~cjlin/libsvm
Please read the COPYRIGHT file before using libsvm.
Table of Contents
=================
- Quick Start
- Installation and Data Format
- `svm-train' Usage
- `svm-predict' Usage
- `svm-scale' Usage
- Tips on Practical Use
- Examples
- Precomputed Kernels
- Library Usage
- Java Version
- Building Windows Binaries
- Additional Tools: Sub-sampling, Parameter Selection, Format checking, etc.
- Python Interface
- Additional Information
Quick Start
===========
If you are new to SVM and if the data is not large, please go to
`tools' directory and use easy.py after installation. It does
everything automatic -- from data scaling to parameter selection.
Usage: easy.py training_file [testing_file]
More information about parameter selection can be found in
`tools/README.'
Installation and Data Format
============================
On Unix systems, type `make' to build the `svm-train' and `svm-predict'
programs. Run them without arguments to show the usages of them.
On other systems, consult `Makefile' to build them (e.g., see
'Building Windows binaries' in this file) or use the pre-built
binaries (Windows binaries are in the directory `windows').
The format of training and testing data file is: